sfFTPLib.idl

Go to the documentation of this file.

// sfFTPLib.idl : IDL source for sfFTPLib
//
// This file will be processed by the MIDL tool to
// produce the type library (sfFTPLib.tlb) and marshalling code.
//
// Notes:
// - .NET doesn't like defaultvalue(0)
 
#include <olectl.h> // DISPID_*
import "oaidl.idl";
import "ocidl.idl";
import "propidl.idl"; // REFPROPVARIANT
#include <WinError.h> // MAKE_HRESULT

// warning MIDL2362 : too many methods in the interface, requires Windows NT 4.0 SP3 or greater.
midl_pragma warning( disable: 2362 )

typedef [v1_enum] enum FTPProtocol
{
    [helpstring("Protocol ftpProtocol Normal")]
    ftpProtocolNormal = 0,

    [helpstring("Protocol ftpProtocol SSL Implicit")]
    ftpProtocolSSLImplicit = 1,

    [helpstring("Protocol ftpProtocol Require TLS")]
    ftpProtocolRequireTLS = 2,

    [helpstring("Protocol ftpProtocol Prefer TLS")]
    ftpProtocolPreferTLS = 4
} FTPProtocol;
 
typedef [v1_enum] enum ProxyType
{
    [helpstring("ProxyType ftpProxyType None")]
    ftpProxyTypeNone = 1,

    [helpstring("ProxyType ftpProxyType SOCKS5")]
    ftpProxyTypeSOCKS5 = 2,

    [helpstring("ProxyType ftpProxyType SOCKS4")]
    ftpProxyTypeSOCKS4 = 3,

    [helpstring("ProxyType ftpProxyType SOCKS4A")]
    ftpProxyTypeSOCKS4A = 4,

    [helpstring("ProxyType ftpProxyType HTTP")]
    ftpProxyTypeHTTP = 5
} ProxyType;

// TODO: rename to FTPPortMode
typedef [v1_enum] enum PortMode
{
    [helpstring("PortMode ftpPortMode Default")]
    ftpPortModeDefault = 1,

    [helpstring("PortMode ftpPortMode Manual")]
    ftpPortModeManual = 2
} PortMode;

// TODO: rename to FTPPassiveIPMode
typedef [v1_enum] enum PassiveMode
{
    [helpstring("PassiveMode ftpPassiveMode UseIPFromReply")]
    ftpPassiveModeUseIPFromReply = 1,

    [helpstring("PassiveMode ftpPassiveMode UseHostIP")]
    ftpPassiveModeUseHostIP = 2,

    [helpstring("PassiveMode ftpPassiveMode Auto")]
    ftpPassiveModeAuto = 3
} PassiveMode;

// TODO: rename to FTPDataTransferType
typedef [v1_enum] enum DataTransferType
{
    [helpstring("DataTransferType ftpDataTransferType Unknown")]
    ftpDataTransferTypeUnknown = 0,
    [helpstring("DataTransferType ftpDataTransferType ASCII")]
    ftpDataTransferTypeASCII = 1,

    [helpstring("DataTransferType ftpDataTransferType Image")]
    ftpDataTransferTypeImage = 2,

    [helpstring("DataTransferType ftpDataTransferType EBCDIC")]
    ftpDataTransferTypeEBCDIC = 3
} DataTransferType;

 // TODO: rename to FTPDataTransferMode
typedef [v1_enum] enum DataTransferMode
{
    [helpstring("DataTransferMode ftpDataTransferMode Unknown")]
    ftpDataTransferModeUnknown = 0,

    [helpstring("DataTransferMode ftpDataTransferMode Stream")]
    ftpDataTransferModeStream = 1,

    [helpstring("DataTransferMode ftpDataTransferMode Z")]
    ftpDataTransferModeZ = 2,
} DataTransferMode;

// TODO: rename to FTPDataProtection
typedef [v1_enum] enum DataProtection
{
    [helpstring("DataProtection ftpDataProtection Unknown")]
    ftpDataProtectionUnknown = 0,

    [helpstring("DataProtection ftpDataProtection Clear")]
    ftpDataProtectionClear = 1,

    [helpstring("DataProtection ftpDataProtection Private")]
    ftpDataProtectionPrivate = 2
} DataProtection;
 
typedef [v1_enum] enum ProtocolFamily
{
    [helpstring("ProtocolFamily ftpProtocolFamily UNSPEC")]
    ftpProtocolFamilyUNSPEC = 0,

    [helpstring("ProtocolFamily ftpProtocolFamily INET4")]
    ftpProtocolFamilyINET4 = 2,

    [helpstring("ProtocolFamily ftpProtocolFamily INET6")]
    ftpProtocolFamilyINET6 = 23
} ProtocolFamily;
 
typedef [v1_enum] enum ServerCapability
{
    [helpstring("ServerCapability ftpServerCapability GetFileSize")]
    ftpServerCapabilityGetFileSize = 0,
 
    [helpstring("ServerCapability ftpServerCapability GetModifyTime")]
    ftpServerCapabilityGetModifyTime = 1,
 
    [helpstring("ServerCapability ftpServerCapability GetCreateTime")]
    ftpServerCapabilityGetCreateTime = 2,
 
    [helpstring("ServerCapability ftpServerCapability SetModifyTime")]
    ftpServerCapabilitySetModifyTime = 3,
 
    [helpstring("ServerCapability ftpServerCapability SetCreateTime")]
    ftpServerCapabilitySetCreateTime = 4,
 
    [helpstring("ServerCapability ftpServerCapability CopyFile")]
    ftpServerCapabilityCopyFile = 5,
 
    [helpstring("ServerCapability ftpServerCapability FXPFile")]
    ftpServerCapabilityFXPFile = 6,
 
    [helpstring("ServerCapability ftpServerCapability Stat")]
    ftpServerCapabilityStat = 7,
 
    [helpstring("ServerCapability ftpServerCapability MLST")]
    ftpServerCapabilityGetMLST = 8,
 
    [helpstring("ServerCapability ftpServerCapability SetUnixPermissions")]
    ftpServerCapabilitySetUnixPermissions = 9,
 
    [helpstring("ServerCapability ftpServerCapability Restart")]
    ftpServerCapabilityRestart = 10,
 
    [helpstring("ServerCapability ftpServerCapability UTF8")]
    ftpServerCapabilityUTF8 = 11,
 
    [helpstring("ServerCapability ftpServerCapability Compression")]
    ftpServerCapabilityCompression = 12,
 
    [helpstring("ServerCapability ftpServerCapability Range")]
    ftpServerCapabilityRange = 13,
 
    [helpstring("ServerCapability ftpServerCapability MachineReadableList")]
    ftpServerCapabilityMachineReadableList = 14
} ServerCapability;
 
typedef [v1_enum] enum ServerCapabilityState
{
    [helpstring("ServerCapabilityState ftpServerCapabilityState Unavailable")]
    ftpServerCapabilityStateUnavailable = 0,
 
    [helpstring("ServerCapabilityState ftpServerCapabilityState Available")]
    ftpServerCapabilityStateAvailable = 1,
 
    [helpstring("ServerCapabilityState ftpServerCapabilityState Unknown")]
    ftpServerCapabilityStateUnknown = 2
} ServerCapabilityState;

typedef [v1_enum] enum CaseSensitivity
{
    [helpstring("CaseSensitivity ftpCaseSensitivity Unknown")]
    ftpCaseSensitivityUnknown = 0,

    [helpstring("CaseSensitivity ftpCaseSensitivity Yes")]
    ftpCaseSensitivityYes = 1,
 
    [helpstring("CaseSensitivity ftpCaseSensitivity No")]
    ftpCaseSensitivityNo = 2
} CaseSensitivity;
 
typedef [v1_enum] enum ParserFormat
{
    [helpstring("ParserFormat ftpParserFormat Unknown")]    ftpParserFormatUnknown = 0,
    [helpstring("ParserFormat ftpParserFormat Unix")]       ftpParserFormatUnix = 1,
    [helpstring("ParserFormat ftpParserFormat MLST")]       ftpParserFormatMLST = 2,
    [helpstring("ParserFormat ftpParserFormat VMS")]        ftpParserFormatVMS = 3,
    [helpstring("ParserFormat ftpParserFormat VxWorks")]    ftpParserFormatVxWorks = 4,
    [helpstring("ParserFormat ftpParserFormat DOS")]        ftpParserFormatDOS = 5,
    [helpstring("ParserFormat ftpParserFormat Tandem")]     ftpParserFormatTandem = 6,
    [helpstring("ParserFormat ftpParserFormat VOS")]        ftpParserFormatVOS = 7,
    [helpstring("ParserFormat ftpParserFormat MVS")]        ftpParserFormatMVS = 8,
    [helpstring("ParserFormat ftpParserFormat AS400")]      ftpParserFormatAS400 = 9,
    [helpstring("ParserFormat ftpParserFormat OS2")]        ftpParserFormatOS2 = 10,
    [helpstring("ParserFormat ftpParserFormat Netware")]    ftpParserFormatNetware = 11,
    [helpstring("ParserFormat ftpParserFormat pSOSystem")]  ftpParserFormatpSOSystem = 12,
    [helpstring("ParserFormat ftpParserFormat NT")]         ftpParserFormatNT = 13,
    [helpstring("ParserFormat ftpParserFormat MD11")]       ftpParserFormatMD11 = 14,
    [helpstring("ParserFormat ftpParserFormat BS2000")]     ftpParserFormatBS2000 = 15,
    [helpstring("ParserFormat ftpParserFormat VM")]     ftpParserFormatVM = 16,
    [helpstring("ParserFormat ftpParserFormat ConnectEnterprise")]      ftpParserFormatConnectEnterprise = 17,
    [helpstring("ParserFormat ftpParserFormat GrassValley")]        ftpParserFormatGrassValley = 18,
    [helpstring("ParserFormat ftpParserFormat Simple")]     ftpParserFormatSimple = 19,
    [helpstring("ParserFormat ftpParserFormat GXSEnterprise")]      ftpParserFormatGXSEnterprise = 20,
    [helpstring("ParserFormat ftpParserFormat GXSInformationExchangeFTPGateway")]       ftpParserFormatGXSInformationExchangeFTPGateway = 21,
    [helpstring("ParserFormat ftpParserFormat SecurePortal2000")] ftpParserFormatSecurePortal2000 = 22,
    [helpstring("ParserFormat ftpParserFormat Meditech")] ftpParserFormatMeditech = 23,
} ParserFormat;

typedef [v1_enum] enum ServerType {
    [helpstring("ServerType ftpServerType Unknown")]
    ftpServerTypeUnknown = 0,

    [helpstring("ServerType ftpServerType Unix")]
    ftpServerTypeUnix = 1,

    [helpstring("ServerType ftpServerType Peter Lewis")]
    ftpServerTypePeterLewis = 2,

    [helpstring("ServerType ftpServerType VMS")]
    ftpServerTypeVMS = 3,

    [helpstring("ServerType ftpServerType NT")]
    ftpServerTypeNT = 4,

    [helpstring("ServerType ftpServerType Amiga")]
    ftpServerTypeAmiga = 5,

    [helpstring("ServerType ftpServerType MacOS")]
    ftpServerTypeMacOS = 6,

    [helpstring("ServerType ftpServerType MVS")]
    ftpServerTypeMVS = 7,

    [helpstring("ServerType ftpServerType AS400")]
    ftpServerTypeAS400 = 8,

    [helpstring("ServerType ftpServerType OS2")]
    ftpServerTypeOS2 = 9,

    [helpstring("ServerType ftpServerType Tandem")]
    ftpServerTypeTandem = 10,

    [helpstring("ServerType ftpServerType VOS")]
    ftpServerTypeVOS = 11,

    [helpstring("ServerType ftpServerType MD11")]
    ftpServerTypeMD11 = 12,

    [helpstring("ServerType ftpServerType pSOSystem")]
    ftpServerTypepSOSystem = 13,

    [helpstring("ServerType ftpServerType Netware")]
    ftpServerTypeNetware = 14,
 
    // --- Specialized / Embedded Systems ---
 
    [helpstring("ServerType ftpServerType TNTEmbeddedToolSuite")]
    ftpServerTypeTNTEmbeddedToolSuite = 15,
 
    [helpstring("ServerType ftpServerType BS2000")]
    ftpServerTypeBS2000 = 16, // Siemens Mainframe
 
    [helpstring("ServerType ftpServerType VM")]
    ftpServerTypeVM = 17, // IBM VM/CMS
 
    [helpstring("ServerType ftpServerType VxWorks")]
    ftpServerTypeVxWorks = 18, // Wind River RTOS
 
    [helpstring("ServerType ftpServerType WindowsCE")]
    ftpServerTypeWindowsCE = 19, // Embedded Windows
 
    [helpstring("ServerType ftpServerType GXSEnterprise")]
    ftpServerTypeGXSEnterprise = 20, // GXS EDI Gateway
 
    [helpstring("ServerType ftpServerType ICS")]
    ftpServerTypeICS = 21,
 
    [helpstring("ServerType ftpServerType GrassValley")]
    ftpServerTypeGrassValley = 22, // Broadcast media servers
 
    [helpstring("ServerType ftpServerType GXSInformationExchangeFTPGateway")]
    ftpServerTypeGXSInformationExchangeFTPGateway = 23,
 
    [helpstring("ServerType ftpServerType SecurePortal2000")]
    ftpServerTypeSecurePortal2000 = 24,

    [helpstring("ServerType ftpServerType MudOS")]
    ftpServerTypeMudOS = 25
 
} ServerType;

typedef [v1_enum] enum ServerSoftware
{
    [helpstring("Unknown")]     ftpServerSoftwareUnknown = 0,
    [helpstring("RaidenFTPd")]      ftpServerSoftwareRaidenFTPd = 1,
    [helpstring("ServU")]           ftpServerSoftwareServU = 2,
    [helpstring("GSFTPS")]          ftpServerSoftwareGSFTPS = 3,
    [helpstring("WSFTP")]           ftpServerSoftwareWSFTP = 4,
    [helpstring("PureFTPd")]        ftpServerSoftwarePureFTPd = 5,
    [helpstring("GuildFTPd")]       ftpServerSoftwareGuildFTPd = 6,
    [helpstring("Titan")]           ftpServerSoftwareTitan = 7,
    [helpstring("Orenosv")]     ftpServerSoftwareOrenosv = 8,
    [helpstring("DrFTPd")]          ftpServerSoftwareDrFTPd = 9,
    [helpstring("moftpd")]          ftpServerSoftwaremoftpd = 10,
    [helpstring("glftpd")]          ftpServerSoftwareglftpd = 11,
    [helpstring("NcFTPd")]          ftpServerSoftwareNcFTPd = 12,
    [helpstring("SurgeFTP")]        ftpServerSoftwareSurgeFTP = 13,
    [helpstring("Blackmoon")]       ftpServerSoftwareBlackmoon = 14,
    [helpstring("WarFTPd")]     ftpServerSoftwareWarFTPd = 15,
    [helpstring("WFTPD")]           ftpServerSoftwareWFTPD = 16,
    [helpstring("ShareIt")]     ftpServerSoftwareShareIt = 17,
    [helpstring("Gene6")]           ftpServerSoftwareGene6 = 18,
//      [helpstring("VxWorks")]     ftpServerSoftwareVxWorks = 19,
    [helpstring("NoFeel")]          ftpServerSoftwareNoFeel = 20,
    [helpstring("MOVEit")]          ftpServerSoftwareMOVEit = 21,
    [helpstring("iNEWS")]           ftpServerSoftwareiNEWS = 22,
    [helpstring("Fastream")]        ftpServerSoftwareFastream = 23,
    [helpstring("ConnectEnterprise")]       ftpServerSoftwareConnectEnterprise = 24,
    [helpstring("MicrosoftFTP")]        ftpServerSoftwareMicrosoftFTP = 25,
    [helpstring("OracleXMLDB")]     ftpServerSoftwareOracleXMLDB = 26,
    [helpstring("FileZilla")]       ftpServerSoftwareFileZilla = 27,
    [helpstring("ProFTPD")]     ftpServerSoftwareProFTPD = 28,
    [helpstring("SnapOS")]      ftpServerSoftwareSnapOS = 29,
    [helpstring("MacOSX")]      ftpServerSoftwareMacOSX = 30,
    [helpstring("cuftpd")]      ftpServerSoftwarecuftpd = 31,
    [helpstring("CerberusFTPServer")]       ftpServerSoftwareCerberusFTPServer = 32,
    [helpstring("zOS")]     ftpServerSoftwarezOS = 33,
    [helpstring("HumaxiCord")]      ftpServerSoftwareHumaxiCord = 34,
    [helpstring("Mtcp")]        ftpServerSoftwareMtcp = 35,
    [helpstring("Ps3")]     ftpServerSoftwarePs3 = 36,
    [helpstring("Meditech")]        ftpServerSoftwareMeditech = 37,
    [helpstring("CleoVLTrader")]    ftpServerSoftwareCleoVLTrader = 38,
    [helpstring("WebMethods")]  ftpServerSoftwareWebMethods = 39,
    [helpstring("JustCloud")]   ftpServerSoftwareJustCloud = 40,
    [helpstring("MultiNet")]    ftpServerSoftwareMultiNet = 41,
    [helpstring("TransCore")]   ftpServerSoftwareTransCore = 42,
    [helpstring("TopfieldPVR")] ftpServerSoftwareTopfieldPVR = 43
} ServerSoftware;
 
typedef [v1_enum] enum OperatingSystem
{
    [helpstring("OperatingSystem ftpOperatingSystem Unknown")]  ftpOperatingSystemUnknown = 0,

    [helpstring("OperatingSystem ftpOperatingSystem Windows")]  ftpOperatingSystemWindows = 1,

    [helpstring("OperatingSystem ftpOperatingSystem Unix")] ftpOperatingSystemUnix = 2,

    [helpstring("OperatingSystem ftpOperatingSystem VMS")]  ftpOperatingSystemVMS = 3
} OperatingSystem;


// TODO: property missing in IFTPConnection
// Used by FTP::OperationSetModifyTime
typedef [v1_enum] enum FTPSetFileTimeCommand
{
    [helpstring("SetFileTimeCommand ftpSetFileTimeCommand Unknown")]
    ftpSetFileTimeCommandUnknown = 0,

    [helpstring("SetFileTimeCommand ftpSetFileTimeCommand Auto")]
    ftpSetFileTimeCommandAuto = 1,

    [helpstring("SetFileTimeCommand ftpSetFileTimeCommand MFMT")]
    ftpSetFileTimeCommandMFMT = 2,

    [helpstring("SetFileTimeCommand ftpSetFileTimeCommand MDTM")]
    ftpSetFileTimeCommandMDTM = 3,

    [helpstring("SetFileTimeCommand ftpSetFileTimeCommand MFF")]
    ftpSetFileTimeCommandMFF = 6
} SetFileTimeCommand;
 
typedef [v1_enum] enum StatusEventType
{
    [helpstring("StatusEventType ftpStatusEventType LocalCommand")]
    ftpStatusEventTypeLocalCommand = 1, 
 
    [helpstring("StatusEventType ftpStatusEventType LocalInfo")]
    ftpStatusEventTypeLocalInfo = 2, 
 
    [helpstring("StatusEventType ftpStatusEventType LocalError")]
    ftpStatusEventTypeLocalError = 4, 
 
    [helpstring("StatusEventType ftpStatusEventType Remote")]
    ftpStatusEventTypeRemote = 5 
} StatusEventType;
 
typedef [v1_enum] enum ConnectionStatus
{
    [helpstring("ConnectionStatus ftpConnectionStatus Unknown")]
    ftpConnectionStatusUnknown = 0,
 
    [helpstring("ConnectionStatus ftpConnectionStatus Connecting")]
    ftpConnectionStatusConnecting = 1, 
 
    [helpstring("ConnectionStatus ftpConnectionStatus Connected")]
    ftpConnectionStatusConnected = 2, 
 
    [helpstring("ConnectionStatus ftpConnectionStatus Disconnecting")]
    ftpConnectionStatusDisconnecting = 3, 
 
    [helpstring("ConnectionStatus ftpConnectionStatus Disconnected")]
    ftpConnectionStatusDisconnected = 4 
} ConnectionStatus;
 
typedef [v1_enum] enum SFTPConnectionStatus
{
    [helpstring("SFTPConnectionStatus ftpSFTPConnectionStatus Unknown")]        
    ftpSFTPConnectionStatusUnknown = 0,

    [helpstring("SFTPConnectionStatus ftpSFTPConnectionStatus Init")]       
    ftpSFTPConnectionStatusInit = 1,

    [helpstring("SFTPConnectionStatus ftpSFTPConnectionStatus Closing")]
    ftpSFTPConnectionStatusClosing = 2
} SFTPConnectionStatus;
 
typedef [v1_enum] enum LogFormat
{
    [helpstring("LogFormat ftpLogFormat Unicode")]
    ftpLogFormatUnicode = 2, 
 
    [helpstring("LogFormat ftpLogFormat UTF8")]
    ftpLogFormatUTF8 = 3 
} LogFormat;
 
typedef [v1_enum] enum HashAlgo
{
    [helpstring("HashAlgo Unknown")] ftpHashAlgoUnknown = 0,
    [helpstring("HashAlgo CRC32")]  ftpHashAlgoCRC32 = 1, 
    [helpstring("HashAlgo MD5")]    ftpHashAlgoMD5= 2, 
    [helpstring("HashAlgo SHA1")]   ftpHashAlgoSHA1 = 3, 
    [helpstring("HashAlgo SHA256")] ftpHashAlgoSHA256 = 4, 
    [helpstring("HashAlgo SHA384")] ftpHashAlgoSHA384 = 5, 
    [helpstring("HashAlgo SHA512")] ftpHashAlgoSHA512 = 6, 
    [helpstring("HashAlgo Microsoft QuickXorHash")] ftpHashAlgoMicrosoftQuickXorHash = 7 
} HashAlgo;

// Internal use only: FTP::OperationTransfer
typedef [v1_enum] enum FTPDataMethod
{
    [helpstring("DataMethod Unknown")]
    ftpDataMethodUnknown = 0,
 
    [helpstring("DataMethod Active")]
    ftpDataMethodActive = 1, 
 
    [helpstring("DataMethod Passive")]
    ftpDataMethodPassive = 2 
} FTPDataMethod;

typedef [v1_enum] enum KeyExchange
{
    [helpstring("KeyExchange Unknown")]
    ftpKeyExchangeUnknown = 0,

    [helpstring("KeyExchange DiffieHellmanGroup14SHA1")]
    ftpKeyExchangeDiffieHellmanGroup14SHA1 = 2,

    [helpstring("KeyExchange DiffieHellmanGroupExchangeSHA1")]
    ftpKeyExchangeDiffieHellmanGroupExchangeSHA1 = 3,

    [helpstring("KeyExchange DiffieHellmanGroupExchangeSHA256")]
    ftpKeyExchangeDiffieHellmanGroupExchangeSHA256 = 4,

    [helpstring("KeyExchange DiffieHellmanGroup14SHA256")]
    ftpKeyExchangeDiffieHellmanGroup14SHA256 = 5,

    [helpstring("KeyExchange DiffieHellmanGroup16SHA512")]
    ftpKeyExchangeDiffieHellmanGroup16SHA512 = 6,

    [helpstring("KeyExchange ECDH256")]
    ftpKeyExchangeECDH256 = 7,

    [helpstring("KeyExchange ECDH384")]
    ftpKeyExchangeECDH384 = 8,

    [helpstring("KeyExchange ECDH521")]
    ftpKeyExchangeECDH521 = 9,

    [helpstring("KeyExchange Curve25519")]
    ftpKeyExchangeCurve25519 = 10,

    [helpstring("KeyExchange Curve25519libssh")]
    ftpKeyExchangeCurve25519libssh = 11,

    [helpstring("KeyExchange MlKem768x25519")]
    ftpKeyExchangeMlKem768x25519 = 12
} KeyExchange;

typedef [v1_enum] enum Encryption
{
    [helpstring("Encryption ftpEncryption Unknown")]
    ftpEncryptionUnknown = 0,
 
    // -------------------------------------------------------------------------
    // Legacy / Deprecated (Avoid)
    // -------------------------------------------------------------------------

    [helpstring("Encryption ftpEncryption 3DES")]
    ftpEncryption3DES = 2,

    [helpstring("Encryption ftpEncryption AES128CBC")]
    ftpEncryptionAES128CBC = 3,

    [helpstring("Encryption ftpEncryption AES192CBC")]
    ftpEncryptionAES192CBC = 4,

    [helpstring("Encryption ftpEncryption AES256CBC")]
    ftpEncryptionAES256CBC = 5,
 
    // -------------------------------------------------------------------------
    // Standard (Safe)
    // -------------------------------------------------------------------------

    [helpstring("Encryption ftpEncryption AES128CTR")]
    ftpEncryptionAES128CTR = 9,

    [helpstring("Encryption ftpEncryption AES192CTR")]
    ftpEncryptionAES192CTR = 10,

    [helpstring("Encryption ftpEncryption AES256CTR")]
    ftpEncryptionAES256CTR = 11,
 
    // -------------------------------------------------------------------------
    // Modern / High Performance (Recommended)
    // -------------------------------------------------------------------------

    [helpstring("Encryption ftpEncryption AES128GCM")]
    ftpEncryptionAES128GCM = 19,

    [helpstring("Encryption ftpEncryption AES256GCM")]
    ftpEncryptionAES256GCM = 20,

//  [helpstring("Encryption ftpEncryption Chacha20")]
//  ftpEncryptionChacha20 = 21,

//  [helpstring("Encryption ftpEncryption Chacha20Poly1305")]
//  ftpEncryptionChacha20Poly1305 = 22,
} Encryption;

typedef [v1_enum] enum HMAC
{
    [helpstring("Unknown")]
    ftpHMACUnknown = 0,

    [helpstring("hmac-sha1: HMAC SHA1")]
    ftpHMACSHA1 = 2,

    [helpstring("none: HMAC None")]
    ftpHMACNone = 6,

    [helpstring("hmac-sha2-256: HMAC SHA2-256")]
    ftpHMACSHA2256 = 8,

    [helpstring("hmac-sha2-512: HMAC SHA2-512")]
    ftpHMACSHA2512 = 9,

    [helpstring("hmac-sha2-256-etm@openssh.com: HMAC SHA2-256 EtM")]
    ftpHMACSHA2256Etm = 10,

    [helpstring("hmac-sha2-512-etm@openssh.com: HMAC SHA2-512 EtM")]
    ftpHMACSHA2512Etm = 11,
} HMAC;

typedef [v1_enum] enum SSHCompression
{
    [helpstring("Unknown: Unspecified or invalid compression method.")]
    ftpSSHCompressionUnknown = 0,

    [helpstring("none: No compression.")]
    ftpSSHCompressionNone = 1,

    [helpstring("zlib@openssh.com: Delayed zlib compression.")]
    ftpSSHCompressionzlibopenssh = 3,
} SSHCompression;

typedef [v1_enum] enum FeatureDiscoveryMode
{
    [helpstring("FeatureDiscoveryMode ftpFeatureDiscoveryMode AfterLogin")]
    ftpFeatureDiscoveryModeAfterLogin = 1,

    [helpstring("FeatureDiscoveryMode ftpFeatureDiscoveryMode BeforeAndAfterLogin")]
    ftpFeatureDiscoveryModeBeforeAndAfterLogin = 2
} FeatureDiscoveryMode;

[
    object,
    uuid(05692BAF-A61B-4692-AB93-58108D48994D),
    dual,
    oleautomation,
    nonextensible,
    helpstring("IGlobal Interface"),
    pointer_default(unique)
]
interface IGlobal : IDispatch
{
    [propget, id(1), helpstring("property Version")] HRESULT Version([out, retval] BSTR* retval);

    [propput, id(4), helpstring("property FIPS")] HRESULT FIPS([in] VARIANT_BOOL newValue);
    [propget, id(4), helpstring("property FIPS")] HRESULT FIPS([out, retval] VARIANT_BOOL* retval);

    [propget, id(7), helpstring("property TotalBytesReceived")] HRESULT TotalBytesReceived([out, retval] ULONGLONG *retval);

    [propget, id(8), helpstring("property TotalBytesSent")] HRESULT TotalBytesSent([out, retval] ULONGLONG *retval);

    [propput, id(9), helpstring("property ActivationUrl")] HRESULT ActivationUrl([in] BSTR newVal);
    [propget, id(9), helpstring("property ActivationUrl")] HRESULT ActivationUrl([out, retval] BSTR *retval);

    [id(12), helpstring("method LoadLicense")] HRESULT LoadLicense([in] BSTR productKey);

//  [id(13), helpstring("method GetActivationRequest")] GetActivationRequest([out] BSTR* activationRequest);
//  [id(14), helpstring("method HandleActivationResponse")] HandleActivationResponse([in] BSTR activationResponse);
};

[   uuid(2F818839-9A89-4821-BBFA-DCB242646EF2),
    object,
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPPortPool Interface"),
    pointer_default(unique)
]
interface IFTPPortPool : IDispatch
{
    [propget, id(1), helpstring("property MinPort")]
    HRESULT MinPort([out, retval] long* retval);

    [propget, id(2), helpstring("property MaxPort")]
    HRESULT MaxPort([out, retval] long* retval);

    [id(100), helpstring("method NextPort")]
    HRESULT NextPort([out, retval] long* retval);

    [id(101), helpstring("method SetPortRange")]
    HRESULT SetPortRange([in] long minPort, [in] long maxPort);
};
 
[
    object,
    uuid(00EF4F3A-9300-4FB7-BC27-7F13D6E1D9BD),
    dual,
    oleautomation,
    nonextensible,
    helpstring("IGlobalSpeedLimit Interface"),
    pointer_default(unique)
]
interface IGlobalSpeedLimit : IDispatch
{
    [propget, id(1), helpstring("property UploadSpeedLimit")]
    HRESULT UploadSpeedLimit([out, retval] long* retval);
    [propput, id(1), helpstring("property UploadSpeedLimit")]
    HRESULT UploadSpeedLimit([in] long newValue);

    [propget, id(2), helpstring("property DownloadSpeedLimit")]
    HRESULT DownloadSpeedLimit([out, retval] long* retval);
    [propput, id(2), helpstring("property DownloadSpeedLimit")]
    HRESULT DownloadSpeedLimit([in] long newValue);
};

typedef [v1_enum] enum ItemType {
    [helpstring("ItemType ftpItemType RegularFile")]
    ftpItemTypeRegularFile = 1,

    [helpstring("ItemType ftpItemType Directory")]
    ftpItemTypeDirectory = 2,

    [helpstring("ItemType ftpItemType SymbolicLink")]
    ftpItemTypeSymbolicLink = 3,

    [helpstring("ItemType ftpItemType Special")]
    ftpItemTypeSpecial = 4,

    [helpstring("ItemType ftpItemType Unknown")]
    ftpItemTypeUnknown = 5,

    [helpstring("ItemType ftpItemType FIFO")]
    ftpItemTypeFIFO = 9,

    [helpstring("ItemType ftpItemType CharacterDevice")]
    ftpItemTypeCharacterDevice = 7,

    [helpstring("ItemType ftpItemType BlockDevice")]
    ftpItemTypeBlockDevice = 8,

    [helpstring("ItemType ftpItemType Socket")]
    ftpItemTypeSocket = 6
 
} ItemType;

[
    object,
    uuid(6E66C7AD-703F-410F-92E6-BB98A702D073),
    oleautomation,
    dual,
    nonextensible,
    helpstring("ISecurityConnectionInfo Interface"),
    pointer_default(unique)
]
interface ISecurityConnectionInfo : IDispatch
{
    [propget, id(1), helpstring("property Protocol")]
    HRESULT Protocol([out, retval] long* retval);

    [propget, id(2), helpstring("property CipherAlgo")]
    HRESULT CipherAlgo([out, retval] BSTR* retval);

    [propget, id(3), helpstring("property CipherStrength")]
    HRESULT CipherStrength([out, retval] long* retval);

    [propget, id(4), helpstring("property HashAlgo")]
    HRESULT HashAlgo([out, retval] BSTR* retval);

    [propget, id(5), helpstring("property HashStrength")]
    HRESULT HashStrength([out, retval] long* retval);

    [propget, id(6), helpstring("property ExchangeAlgo")]
    HRESULT ExchangeAlgo([out, retval] BSTR* retval);

    [propget, id(7), helpstring("property ExchangeStrength")]
    HRESULT ExchangeStrength([out, retval] long* retval);
};
 
[
    object,
    uuid(B11A9B35-27A7-4387-B089-B1B632A8059F),
    nonextensible,
    pointer_default(unique)
]
interface IStreamFilter : IUnknown
{
    // Do not use a IStream as argument otherwise the proxy stubs for IStream and ISequentialStream are generated which is not what we want
    // This is the case because the manifest adds <comInterfaceExternalProxyStub > for IStream
    HRESULT Initialize([in] IStream* stream);
    HRESULT Uninitialize();
    HRESULT GetStream([out] IStream** stream);
};
 
[
    object,
    uuid(411899B9-5F68-40EF-BE59-044A393C34A2),
    nonextensible,
    pointer_default(unique)
]
interface IStreamFilterInfo : IUnknown
{
    [propget] HRESULT AlignSize([out, retval] long* retval);
};

[
    object,
    uuid(44875A47-88B4-4310-A777-5A63261355EE),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPClientId Interface"),
    pointer_default(unique)
]
interface IFTPClientId : IDispatch
{
    [propput, id(1), helpstring("property Name")] 
    HRESULT Name([in] BSTR newValue);
    [propget, id(1), helpstring("property Name")] 
    HRESULT Name([out, retval] BSTR* retval);

    [propput, id(2), helpstring("property Version")] 
    HRESULT Version([in] BSTR newValue);
    [propget, id(2), helpstring("property Version")] 
    HRESULT Version([out, retval] BSTR* retval);
};

[
    object,
    uuid(CDEE9011-5363-455A-BD11-E3C49CECDB3F),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPServerId Interface"),
    pointer_default(unique)
]
interface IFTPServerId : IDispatch
{
    [propget, id(1), helpstring("property Name")]
    HRESULT Name([out, retval] BSTR* retval);

    [propget, id(2), helpstring("property Version")]
    HRESULT Version([out, retval] BSTR* retval);

    [propget, id(3), helpstring("property CaseSensitivity")]
    HRESULT CaseSensitivity([out, retval] CaseSensitivity* retval);
};
 
[
    object,
    uuid(19D50DD2-F381-4DA0-923D-DA672ABA7824),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPServerState Interface"),
    pointer_default(unique)
]
interface IFTPServerState : IDispatch
{
    [propget, id(1), helpstring("property CodePage")]
    HRESULT CodePage([out, retval] long* retval);

    [propget, id(2), helpstring("property DataProtection")]
    HRESULT DataProtection([out, retval] DataProtection* retval);

    [propget, id(15), helpstring("property CommandProtection")]
    HRESULT CommandProtection([out, retval] DataProtection* retval);

    [propget, id(3), helpstring("property DataTransferType")]
    HRESULT DataTransferType([out, retval] DataTransferType* retval);

    [propget, id(4), helpstring("property DataTransferMode")]
    HRESULT DataTransferMode([out, retval] DataTransferMode* retval);

    [propget, id(6), helpstring("property ServerType")]
    HRESULT ServerType([out, retval] ServerType* retval);

    [propget, id(7), helpstring("property ServerSoftware")]
    HRESULT ServerSoftware([out, retval] ServerSoftware* retval);

    [propget, id(8), helpstring("property PBSZ")]
    HRESULT PBSZ([out, retval] VARIANT_BOOL* retval);

    [propget, id(9), helpstring("property SSCN")]
    HRESULT SSCN([out, retval] VARIANT_BOOL* retval);

    [propget, id(10), helpstring("property WorkingDirectory")]
    HRESULT WorkingDirectory([out, retval] BSTR* retval);

    [propget, id(16), helpstring("property HomeDirectory")]
    HRESULT HomeDirectory([out, retval] BSTR* retval);

    [propget, id(11), helpstring("property SYSTReply")]
    HRESULT SYSTReply([out, retval] BSTR* retval);

    [propget, id(12), helpstring("property FEATReply")]
    HRESULT FEATReply([out, retval] BSTR* retval);

    [propget, id(13), helpstring("property WelcomeMessage")]
    HRESULT WelcomeMessage([out, retval] BSTR* retval);

    [propget, id(14), helpstring("property ServerId")]
    HRESULT ServerId([out, retval] IFTPServerId ** retval);

    [propget, id(103), helpstring("property OperatingSystem")]
    HRESULT OperatingSystem([out, retval] OperatingSystem *retval);
 
    [id(101), helpstring("method EvaluateParserFormat")]
    HRESULT EvaluateParserFormat([out, retval] ParserFormat *retval);

    [id(105), helpstring("method GetCaseSensitivity")]
    HRESULT GetCaseSensitivity([out, retval] CaseSensitivity* retval);
 
    [id(108), helpstring("method GetServerCapabilityState")]
    HRESULT GetServerCapabilityState([in] ServerCapability capability, [out, retval] ServerCapabilityState* retval);

    [id(104), helpstring("method IsHashAlgoAvailable")]
    HRESULT IsHashAlgoAvailable([in] HashAlgo algo, [out, retval] VARIANT_BOOL* retval);

    [id(106), helpstring("method LookupFeature")]
    HRESULT LookupFeature([in] BSTR key, [out] BSTR *value, [out, retval] VARIANT_BOOL *retval);
};
 
typedef [v1_enum] enum KeyType
{
    [helpstring("KeyType ftpKeyType Unknown")]
    ftpKeyTypeUnknown = 0,

    [helpstring("KeyType ftpKeyType PrivateKey")]
    ftpKeyTypePublicKey = 1,

    [helpstring("KeyType ftpKeyType PublicKey")]
    ftpKeyTypePrivateKey = 2
} KeyType;
 
typedef [v1_enum] enum KeyAlgo
{
    [helpstring("KeyAlgo ftpKeyAlgo Unknown")]  
    ftpKeyAlgoUnknown = 0,

    [helpstring("KeyAlgo ftpKeyAlgo RSA")]  
    ftpKeyAlgoRSA = 1,

    [helpstring("KeyAlgo ftpKeyAlgo DSA")]  
    ftpKeyAlgoDSA = 2,

    [helpstring("KeyAlgo ftpKeyAlgo ECDSAP256")]    
    ftpKeyAlgoECDSAP256 = 3,

    [helpstring("KeyAlgo ftpKeyAlgo ECDSAP384")]    
    ftpKeyAlgoECDSAP384 = 4,

    [helpstring("KeyAlgo ftpKeyAlgo ECDSAP521")]    
    ftpKeyAlgoECDSAP521 = 5,

    [helpstring("KeyAlgo ftpKeyAlgo Ed25519")]  
    ftpKeyAlgoEd25519 = 6,

    [helpstring("KeyAlgo ftpKeyAlgo Ed448")]    
    ftpKeyAlgoEd448 = 7,

    [helpstring("KeyAlgo ftpKeyAlgo MlDsa44")]  
    ftpKeyAlgoMlDsa44 = 8,

    [helpstring("KeyAlgo ftpKeyAlgo MlDsa65")]  
    ftpKeyAlgoMlDsa65 = 9,

    [helpstring("KeyAlgo ftpKeyAlgo MlDsa87")]  
    ftpKeyAlgoMlDsa87 = 10,
} KeyAlgo;

typedef [v1_enum] enum SSHPublicKeyAlgo
{
    [helpstring("Unknown: Unspecified or invalid algorithm.")]
    ftpSSHPublicKeyAlgoUnknown = 0,
 
    // --- RSA Family (Classic) ---

    [helpstring("ssh-rsa: Legacy RSA with SHA-1. Deprecated; use SHA-2 variants instead.")]
    ftpSSHPublicKeyAlgoRSA = 1,

    [helpstring("rsa-sha2-256: RSA with SHA-256.")]
    ftpSSHPublicKeyAlgoRSASHA2256 = 20,

    [helpstring("rsa-sha2-512: RSA with SHA-512.")]
    ftpSSHPublicKeyAlgoRSASHA2512 = 21,
 
    // --- Elliptic Curve Family (ECDSA / EdDSA) ---

    [helpstring("ecdsa-sha2-nistp256: NIST P-256 Curve. Standard ECDSA variant.")]
    ftpSSHPublicKeyAlgoECDSA256 = 8,

    [helpstring("ecdsa-sha2-nistp384: NIST P-384 Curve.")]
    ftpSSHPublicKeyAlgoECDSA384 = 9,

    [helpstring("ecdsa-sha2-nistp521: NIST P-521 Curve.")]
    ftpSSHPublicKeyAlgoECDSA521 = 10,

    [helpstring("ssh-ed25519: Curve25519 signature.")]
    ftpSSHPublicKeyAlgoEd25519 = 14,

    [helpstring("ssh-ed448: EdDSA using the Goldilocks curve.")]
    ftpSSHPublicKeyAlgoEd448 = 30,
 
    // --- Post-Quantum (ML-DSA / Crystals-Dilithium) ---

    [helpstring("ml-dsa-44: NIST Post-Quantum signature.")]
    ftpSSHPublicKeyAlgoMlDsa44 = 31,

    [helpstring("ml-dsa-65: NIST Post-Quantum signature.")]
    ftpSSHPublicKeyAlgoMlDsa65 = 32,

    [helpstring("ml-dsa-87: NIST Post-Quantum signature.")]
    ftpSSHPublicKeyAlgoMlDsa87 = 33,
 
    // --- X.509 Certificate Variants ---

    [helpstring("x509v3-sign-rsa: RSA signatures using X.509v3 certificates.")]
    ftpSSHPublicKeyAlgox509v3RSA = 3,

    [helpstring("x509v3-ecdsa-sha2-nistp256: ECDSA signatures using X.509v3 certificates.")]
    ftpSSHPublicKeyAlgox509v3ECDSA256 = 11,

    [helpstring("x509v3-ecdsa-sha2-nistp384: ECDSA P-384 signatures using X.509v3 certificates.")]
    ftpSSHPublicKeyAlgox509v3ECDSA384 = 12,

    [helpstring("x509v3-ecdsa-sha2-nistp521: ECDSA P-521 signatures using X.509v3 certificates.")]
    ftpSSHPublicKeyAlgox509v3ECDSA521 = 13,

    [helpstring("x509v3-rsa2048-sha256: RSA-2048 with SHA-256 using X.509v3 certificates.")]
    ftpSSHPublicKeyAlgox509v3RSA2048SHA256 = 15,
 
    // --- OpenSSH Certificate Variants ---

    [helpstring("rsa-sha2-256-cert-v01@openssh.com: OpenSSH Certificate based on RSA SHA-256.")]
    ftpSSHPublicKeyAlgoRSASHA2256CertOpenSSH = 28,

    [helpstring("rsa-sha2-512-cert-v01@openssh.com: OpenSSH Certificate based on RSA SHA-512.")]
    ftpSSHPublicKeyAlgoRSASHA2512CertOpenSSH = 29,

    [helpstring("ssh-ed25519-cert-v01@openssh.com: OpenSSH Certificate based on Ed25519.")]
    ftpSSHPublicKeyAlgoEd25519CertOpenSSH = 27,

    [helpstring("ssh-rsa-cert-v01@openssh.com: Legacy OpenSSH RSA Certificate (SHA-1).")]
    ftpSSHPublicKeyAlgoRSACertOpenSSH = 22,

    [helpstring("ssh-dss-cert-v01@openssh.com: Legacy OpenSSH DSA Certificate.")]
    ftpSSHPublicKeyAlgoDSACertOpenSSH = 23,

    [helpstring("ecdsa-sha2-nistp256-cert-v01@openssh.com: OpenSSH Certificate based on ECDSA P-256.")]
    ftpSSHPublicKeyAlgoECDSA256CertOpenSSH = 24,

    [helpstring("ecdsa-sha2-nistp384-cert-v01@openssh.com: OpenSSH Certificate based on ECDSA P-384.")]
    ftpSSHPublicKeyAlgoECDSA384CertOpenSSH = 25,

    [helpstring("ecdsa-sha2-nistp521-cert-v01@openssh.com: OpenSSH Certificate based on ECDSA P-521.")]
    ftpSSHPublicKeyAlgoECDSA521CertOpenSSH = 26,
 
    // --- Legacy / Insecure ---

    [helpstring("ssh-dss: Legacy Digital Signature Algorithm. Deprecated and insecure.")]
    ftpSSHPublicKeyAlgoDSA = 2
} SSHPublicKeyAlgo;
 
typedef [v1_enum] enum CertificateType
{
    [helpstring("Unknown")]
    CertificateTypeUnknown = 0,

    [helpstring("X.509: Standard Public Key Infrastructure")]
    CertificateTypex509 = 1,

    [helpstring("OpenSSH: SSH Proprietary Certificate")]
    CertificateTypeOpenSSH = 2,
} CertificateType;

[
    uuid(DEA6D5FC-1CA3-4d58-876C-5D0C4C02F835),    // IID_IKey
    object,
    oleautomation,
    dual,
    nonextensible,
    helpstring("IKey Interface"),
    pointer_default(unique)
]
interface IKey : IDispatch
{
    [propget, id(1), helpstring("property Type")] 
    HRESULT Type([out, retval] KeyType* retval);

    [propget, id(2), helpstring("property Bits")] 
    HRESULT Bits([out, retval] long* retval);

    [propget, id(3), helpstring("property Algo")] 
    HRESULT Algo([out, retval] KeyAlgo* retval);

    [propget, id(4), helpstring("property Certificate")] 
    HRESULT Certificate([out, retval] VARIANT* retval);

    [propget, id(5), helpstring("property CertificateType")] 
    HRESULT CertificateType([out, retval] CertificateType* retval);

    [id(22), helpstring("method ImportBlob")] 
    HRESULT ImportBlob(
        [in] LPCWSTR pszBlobType, 
        [in, size_is(cbInput)] byte* pbInput, 
        [in] ULONG cbInput
    );

    [id(23), helpstring("method Verify")] 
    HRESULT Verify(
        [in] HashAlgo hashAlgo, 
        [in, size_is(cbSignature)] byte* pbSignature, 
        [in] ULONG cbSignature, 
        [in, size_is(cbInput)] byte* pbInput, 
        [in] ULONG cbInput, 
        [in] ULONG flags
    );

    [id(24), helpstring("method ExportKey")] 
    HRESULT ExportKey(
        [in] LPCWSTR pszBlobType, 
        [out, size_is(*pcbData)] byte* pbData, 
        [in,out] ULONG *pcbData
    );

    [id(25), helpstring("method Sign")] 
    HRESULT Sign(
        [in] HashAlgo hashAlgo, 
        [in, size_is(cbInput)] byte* pbInput, 
        [in] ULONG cbInput, 
        [out, size_is(*pcbSignature)] byte* pbSignature, 
        [in,out] ULONG *pcbSignature, 
        [in] ULONG flags
    );

    [id(26), helpstring("method SetProperty")] 
    HRESULT SetProperty(
        [in] LPCWSTR pszProperty, 
        [in, size_is(cbInput)] byte* pbInput, 
        [in] ULONG cbInput, 
        [in] ULONG dwFlags
    );
};

[
    object,
    uuid(67888DE9-428E-4CCE-B0A5-97D0883142A6),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IProxySettings Interface"),
    pointer_default(unique)
]
interface IProxySettings : IDispatch
{
    [propput, id(1), helpstring("property Host")]
    HRESULT Host([in] BSTR newValue);
    [propget, id(1), helpstring("property Host")]
    HRESULT Host([out, retval] BSTR* retval);

    [propput, id(2), helpstring("property Port")]
    HRESULT Port([in] long newValue);
    [propget, id(2), helpstring("property Port")]
    HRESULT Port([out, retval] long* retval);

    [propput, id(3), helpstring("property Type")]
    HRESULT Type([in] ProxyType newValue);
    [propget, id(3), helpstring("property Type")]
    HRESULT Type([out, retval] ProxyType* retval);

    [propput, id(4), helpstring("property Authentication")]
    HRESULT Authentication([in] VARIANT_BOOL newValue);
    [propget, id(4), helpstring("property Authentication")]
    HRESULT Authentication([out, retval] VARIANT_BOOL* retval);

    [propput, id(5), helpstring("property Username")]
    HRESULT Username([in] BSTR newValue);
    [propget, id(5), helpstring("property Username")]
    HRESULT Username([out, retval] BSTR* retval);

    [propput, id(6), helpstring("property Password")]
    HRESULT Password([in] BSTR newValue);
    [propget, id(6), helpstring("property Password")]
    HRESULT Password([out, retval] BSTR* retval);

    [propput, id(8), helpstring("property ProtocolFamily")]
    HRESULT ProtocolFamily([in] long newValue);
    [propget, id(8), helpstring("property ProtocolFamily")]
    HRESULT ProtocolFamily([out, retval] long* retval);

    [propput, id(9), helpstring("property ProtocolFamilyPreference")]
    HRESULT ProtocolFamilyPreference([in] long newValue);
    [propget, id(9), helpstring("property ProtocolFamilyPreference")]
    HRESULT ProtocolFamilyPreference([out, retval] long* retval);
};
 
[
    object,
    uuid(2A36B23A-4D39-47E6-A659-FF457D19AEC1),
    oleautomation,
    dual,
    nonextensible,
    helpstring("ISocketSettings Interface"),
    pointer_default(unique)
]
interface ISocketSettings : IDispatch
{
    [propput, id(114), helpstring("property SendBufferSize")]
    HRESULT SendBufferSize([in] long newValue);
    [propget, id(114), helpstring("property SendBufferSize")]
    HRESULT SendBufferSize([out, retval] long* retval);

    [propput, id(115), helpstring("property ReceiveBufferSize")]
    HRESULT ReceiveBufferSize([in] long newValue);
    [propget, id(115), helpstring("property ReceiveBufferSize")]
    HRESULT ReceiveBufferSize([out, retval] long* retval);

    [propput, id(164), helpstring("property AutoTuneSendBufferSize")]
    HRESULT AutoTuneSendBufferSize([in] VARIANT_BOOL newValue);
    [propget, id(164), helpstring("property AutoTuneSendBufferSize")]
    HRESULT AutoTuneSendBufferSize([out, retval] VARIANT_BOOL* retval);

    [propput, id(163), helpstring("property AutoTuneReceiveBufferSize")]
    HRESULT AutoTuneReceiveBufferSize([in] VARIANT_BOOL newValue);
    [propget, id(163), helpstring("property AutoTuneReceiveBufferSize")]
    HRESULT AutoTuneReceiveBufferSize([out, retval] VARIANT_BOOL* retval);

    [propput, id(9), helpstring("property TcpNoDelay")]
    HRESULT TcpNoDelay([in] VARIANT_BOOL newValue);
    [propget, id(9), helpstring("property TcpNoDelay")]
    HRESULT TcpNoDelay([out, retval] VARIANT_BOOL* retval);
};
 
[
    object,
    uuid(43F64D39-D795-43E7-AD13-4AC58A16706E),
    oleautomation,
    dual,
    nonextensible,
    helpstring("ISpeedLimitSettings Interface"),
    pointer_default(unique)
]
interface ISpeedLimitSettings : IDispatch
{
    [propget, id(1), helpstring("property UploadSpeedLimit")]
    HRESULT UploadSpeedLimit([out, retval] long* retval);
    [propput, id(1), helpstring("property UploadSpeedLimit")]
    HRESULT UploadSpeedLimit([in] long newValue);

    [propget, id(2), helpstring("property DownloadSpeedLimit")]
    HRESULT DownloadSpeedLimit([out, retval] long* retval);
    [propput, id(2), helpstring("property DownloadSpeedLimit")]
    HRESULT DownloadSpeedLimit([in] long newValue);
};
 
[
    object,
    uuid(E73FB5C8-7B36-49D0-B491-C5C0E34640E3),
    pointer_default(unique)
]
interface ICompletionHandler : IUnknown
{
    HRESULT OnComplete([in] HRESULT error);
}
 
[
    object,
    uuid(294F6B85-F0F9-4A29-8125-609C20BC4226),
    oleautomation,
    dual,
    nonextensible,
    helpstring("ITlsSocket Interface"),
    pointer_default(unique)
]
interface ITlsSocket : IDispatch
{
    [propget, id(13), helpstring("property Enabled")]
    HRESULT Enabled([out, retval] VARIANT_BOOL* retval);

    [propput, id(14), helpstring("property ClientCertThumbprint")]
    HRESULT ClientCertThumbprint([in] VARIANT thumbprint);
    [propget, id(14), helpstring("property ClientCertThumbprint")]
    HRESULT ClientCertThumbprint([out, retval] VARIANT* retval);

    [propput, id(15), helpstring("property ClientCertStore")]
    HRESULT ClientCertStore([in] BSTR newValue);
    [propget, id(15), helpstring("property ClientCertStore")]
    HRESULT ClientCertStore([out, retval] BSTR* retval);

    [propput, id(16), helpstring("property ClientCertStoreLocation")]
    HRESULT ClientCertStoreLocation([in] long newValue);
    [propget, id(16), helpstring("property ClientCertStoreLocation")]
    HRESULT ClientCertStoreLocation([out, retval] long* retval);

    [propget, id(20), helpstring("property ConnectionInfo")]
    HRESULT ConnectionInfo([out, retval] ISecurityConnectionInfo **retval);
 
    [propget, id(17), helpstring("property RemoteCert")]
    HRESULT RemoteCert([out,retval] VARIANT* retval);

    [propput, id(21), helpstring("property DisabledProtocols")]
    HRESULT DisabledProtocols([in] long newValue);
    [propget, id(21), helpstring("property DisabledProtocols")]
    HRESULT DisabledProtocols([out, retval] long* retval);
};
 
[
    object,
    uuid(58B37E37-9F86-4348-8698-A3D7A0A81EF5),
    dual,
    nonextensible,
    helpstring("ISFTPExtendedCheckFileResult Interface"),
    pointer_default(unique)
]
interface ISFTPExtendedCheckFileResult : IDispatch
{
    [propget, id(1), helpstring("property HashAlgo")]
    HRESULT HashAlgo([out, retval] HashAlgo* retval);

    [propget, id(2), helpstring("property HashAsString")]
    HRESULT HashAsString([out, retval] BSTR* retval);
};
 
[
    object,
    uuid(BB665147-7336-47C5-AFF4-DB5819BD29CE),
    pointer_default(unique)
]
interface ILogger : IUnknown
{
    // midl doesn't support 64-bit SIZE_T for size_is()
    HRESULT Log([in] StatusEventType eventType, [in, size_is(textLength)] LPCWSTR text, [in] UINT textLength);
};
 
[
    object,
    uuid(8ABB3C80-5D7E-4C5F-9B9E-41161B498114),
    pointer_default(unique)
]
interface IConnectionWithLogger : IUnknown
{
    HRESULT SetLogger([in, unique] ILogger* logger);
    HRESULT GetLogger([out] ILogger** logger);
};
 
[
    object,
    uuid(BC45DF1A-883F-4CEB-B6EA-9DFC2F0E83B4),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFileLogger Interface"),
    pointer_default(unique)
]
interface IFileLogger : IDispatch
{
    [propput, id(1), helpstring("property File")]
    HRESULT File([in] BSTR newValue);
    [propget, id(1), helpstring("property File")]
    HRESULT File([out, retval] BSTR* retval);

    [propput, id(2), helpstring("property Format")]
    HRESULT Format([in] LogFormat newValue);
    [propget, id(2), helpstring("property Format")]
    HRESULT Format([out, retval] LogFormat* retval);
 
    [id(100), helpstring("method WriteLog")]
    HRESULT WriteLog([in] BSTR text);
};
 
typedef [v1_enum] enum FTPItemAttribute
{
    [helpstring("ItemAttribute ftpFTPItemAttribute Size")]              ftpFTPItemAttributeSize = 0x1,
    [helpstring("ItemAttribute ftpFTPItemAttribute Permissions")]       ftpFTPItemAttributePermissions = 0x4,
    [helpstring("ItemAttribute ftpFTPItemAttribute AccessTime")]        ftpFTPItemAttributeAccessTime = 0x8,
    [helpstring("ItemAttribute ftpFTPItemAttribute CreateTime")]        ftpFTPItemAttributeCreateTime = 0x10,
    [helpstring("ItemAttribute ftpFTPItemAttribute ModifyTime")]        ftpFTPItemAttributeModifyTime = 0x20,
    [helpstring("ItemAttribute ftpFTPItemAttribute ACL")]               ftpFTPItemAttributeACL = 0x40,
    [helpstring("ItemAttribute ftpFTPItemAttribute SubSecondTimes")]    ftpFTPItemAttributeSubSecondTimes = 0x100,
    [helpstring("ItemAttribute ftpFTPItemAttribute Bits")]              ftpFTPItemAttributeBits = 0x200,
    [helpstring("ItemAttribute ftpFTPItemAttribute AllocationSize")]    ftpFTPItemAttributeAllocationSize = 0x400,
    [helpstring("ItemAttribute ftpFTPItemAttribute TextHint")]          ftpFTPItemAttributeTextHint = 0x800,
    [helpstring("ItemAttribute ftpFTPItemAttribute MimeType")]          ftpFTPItemAttributeMimeType = 0x1000,
    [helpstring("ItemAttribute ftpFTPItemAttribute LinkCount")]     ftpFTPItemAttributeLinkCount = 0x2000,
    [helpstring("ItemAttribute ftpFTPItemAttribute UntranslatedName")]  ftpFTPItemAttributeUntranslatedName = 0x4000,
    [helpstring("ItemAttribute ftpFTPItemAttribute CTime")]         ftpFTPItemAttributeCTime = 0x8000,
    [helpstring("ItemAttribute ftpFTPItemAttribute Extended")]          ftpFTPItemAttributeExtended = 0x80000000,
    [helpstring("ItemAttribute ftpFTPItemAttribute Owner")]         ftpFTPItemAttributeOwner = 0x10000,
    [helpstring("ItemAttribute ftpFTPItemAttribute UnixPermissions")]   ftpFTPItemAttributeUnixPermissions = 0x20000,
    [helpstring("ItemAttribute ftpFTPItemAttribute WindowsAttributes")] ftpFTPItemAttributeWindowsAttributes = 0x40000,
    [helpstring("ItemAttribute ftpFTPItemAttribute Group")]             ftpFTPItemAttributeGroup = 0x80000,
} FTPItemAttribute;

[
    object,
    uuid(36CE9B15-1CF2-4E76-9D1B-069DDB0E7C9D),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPItem Interface"),
    pointer_default(unique)
]
interface IFTPItem : IDispatch
{
    [propput, id(1), helpstring("property Name")]
    HRESULT Name([in] BSTR newValue);
    [propget, id(1), helpstring("property Name")]
    HRESULT Name([out, retval] BSTR* retval);

    [propput, id(2), helpstring("property Type")]
    HRESULT Type([in] ItemType newType);
    [propget, id(2), helpstring("property Type")]
    HRESULT Type([out, retval] ItemType* retval);

    [propput, id(3), helpstring("property Owner")]
    HRESULT Owner([in] BSTR newValue);
    [propget, id(3), helpstring("property Owner")]
    HRESULT Owner([out, retval] BSTR* retval);

    [propput, id(4), helpstring("property Group")]
    HRESULT Group([in] BSTR newValue);
    [propget, id(4), helpstring("property Group")]
    HRESULT Group([out, retval] BSTR* retval);

    [propput, id(5), helpstring("property Size")]
    HRESULT Size([in] ULONGLONG newValue);
    [propget, id(5), helpstring("property Size")]
    HRESULT Size([out, retval] ULONGLONG* retval);

    [propget, id(6), helpstring("property SizeLo")]
    HRESULT SizeLo([out, retval] long* retval);

    [propget, id(7), helpstring("property SizeHi")]
    HRESULT SizeHi([out, retval] long* retval);

    [propput, id(10), helpstring("property ModifyTime")]
    HRESULT ModifyTime([in] FILETIME newValue);
    [propget, id(10), helpstring("property ModifyTime")]
    HRESULT ModifyTime([out, retval] FILETIME* retval);
 
    [propput, id(9), helpstring("property ModifyTimeAsDate")]
    HRESULT ModifyTimeAsDate([in] VARIANT newValue);
    [propget, id(9), helpstring("property ModifyTimeAsDate")]
    HRESULT ModifyTimeAsDate([out, retval] VARIANT* retval);

    [propput, id(16), helpstring("property AccessTime")]
    HRESULT AccessTime([in] FILETIME newValue);
    [propget, id(16), helpstring("property AccessTime")]
    HRESULT AccessTime([out, retval] FILETIME* retval);

    [propput, id(17), helpstring("property CreateTime")]
    HRESULT CreateTime([in] FILETIME newValue);
    [propget, id(17), helpstring("property CreateTime")]
    HRESULT CreateTime([out, retval] FILETIME* retval);

    [propput, id(28), helpstring("property CTime")]
    HRESULT CTime([in] FILETIME newValue);
    [propget, id(28), helpstring("property CTime")]
    HRESULT CTime([out, retval] FILETIME* retval);
 
    [propput, id(12), helpstring("property CreateTimeAsDate")]
    HRESULT CreateTimeAsDate([in] VARIANT newValue);
    [propget, id(12), helpstring("property CreateTimeAsDate")]
    HRESULT CreateTimeAsDate([out, retval] VARIANT* retval);
 
    [propput, id(15), helpstring("property AccessTimeAsDate")]
    HRESULT AccessTimeAsDate([in] VARIANT newValue);
    [propget, id(15), helpstring("property AccessTimeAsDate")]
    HRESULT AccessTimeAsDate([out, retval] VARIANT* retval);
 
    [propput, id(27), helpstring("property CTimeAsDate")]
    HRESULT CTimeAsDate([in] VARIANT newValue);
    [propget, id(27), helpstring("property CTimeAsDate")]
    HRESULT CTimeAsDate([out, retval] VARIANT* retval);

    [propput, id(20), helpstring("property AttributeBits")]
    HRESULT AttributeBits([in] long newValue);
    [propget, id(20), helpstring("property AttributeBits")]
    HRESULT AttributeBits([out, retval] long* retval);

    [propput, id(21), helpstring("property ValidAttributeBits")]
    HRESULT ValidAttributeBits([in] long newValue);
    [propget, id(21), helpstring("property ValidAttributeBits")]
    HRESULT ValidAttributeBits([out, retval] long* retval);

    [propput, id(22), helpstring("property UnixFilePermissions")]
    HRESULT UnixFilePermissions([in] long newValue);
    [propget, id(22), helpstring("property UnixFilePermissions")]
    HRESULT UnixFilePermissions([out, retval] long* retval);

    [propput, id(23), helpstring("property AllocationSize")]
    HRESULT AllocationSize([in] ULONGLONG newValue);
    [propget, id(23), helpstring("property AllocationSize")]
    HRESULT AllocationSize([out, retval] ULONGLONG* retval);
 
    [propput, id(24), helpstring("property MimeType")]
    HRESULT MimeType([in] BSTR newValue);
    [propget, id(24), helpstring("property MimeType")]
    HRESULT MimeType([out, retval] BSTR* retval);

    [propput, id(25), helpstring("property LinkPoint")]
    HRESULT LinkPoint([in] BSTR newValue);
    [propget, id(25), helpstring("property LinkPoint")]
    HRESULT LinkPoint([out, retval] BSTR* retval);
 
    [propput, id(26), helpstring("property Unique")]
    HRESULT Unique([in] BSTR newValue);
    [propget, id(26), helpstring("property Unique")]
    HRESULT Unique([out, retval] BSTR* retval);

    [propput, id(29), helpstring("property UTC")]
    HRESULT UTC([in] VARIANT_BOOL newValue);
    [propget, id(29), helpstring("property UTC")]
    HRESULT UTC([out, retval] VARIANT_BOOL* retval);
 
    [propput, id(30), helpstring("property TimePrecision")]
    HRESULT TimePrecision([in] long newValue);
    [propget, id(30), helpstring("property TimePrecision")]
    HRESULT TimePrecision([out, retval] long * retval);

    [id(101), helpstring("method IsValidAttribute")]
    HRESULT IsValidAttribute([in] FTPItemAttribute attribute, [out, retval] VARIANT_BOOL* retval);
};
 
[
    object,
    uuid(9055CECB-7F8F-4B16-AA4D-4D21CC6485E9),
    dual,
    oleautomation,
    nonextensible,
    helpstring("IFTPItems Interface"),
    pointer_default(unique)
]
interface IFTPItems : IDispatch
{
    [propget, id(DISPID_VALUE), helpstring("method Item")]
    HRESULT Item( [in] long index, [out,retval] IFTPItem** item);
 
    [propget, id(DISPID_NEWENUM), restricted, helpstring("method _NewEnum")]
    HRESULT _NewEnum([out, retval] IUnknown** retval);

    [propget, id(1), helpstring("property Count")]
    HRESULT Count([out, retval] long* retval);
 
    HRESULT GetAt([in] UINT index, [out,retval] IFTPItem** item);
    [propget] HRESULT Size([out, retval] UINT* size);
};

[
    object,
    uuid(8C1FDFC9-14A3-478F-88A2-EFF54CA87662),
    pointer_default(unique)
]
interface ITransferProgressEvents : IUnknown
{
    HRESULT OnTransferProgress([in] ULONGLONG bytesTransferred);
};
 
interface ISFTPSpaceAvailable;
 
[   uuid(65D75061-6343-4124-9D64-64F1EABB34C2),    // IID_IFTPConnection
    object,
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPConnection Interface"),
    pointer_default(unique)
]
interface IFTPConnection : IDispatch
{
    // OperationHandler
    [propget, id(2), helpstring("property Busy")]
    HRESULT Busy([out, retval] VARIANT_BOOL* retval);

    [propget, id(119), helpstring("property Aborted")]
    HRESULT Aborted([out, retval] VARIANT_BOOL* retval);

    [propput, id(117), helpstring("property UseMessageLoop")]
    HRESULT UseMessageLoop([in] VARIANT_BOOL newValue);
    [propget, id(117), helpstring("property UseMessageLoop")]
    HRESULT UseMessageLoop([out, retval] VARIANT_BOOL* retval);

    [propput, id(19), helpstring("property Timeout")]
    HRESULT Timeout([in] long newValue);
    [propget, id(19), helpstring("property Timeout")]
    HRESULT Timeout([out, retval] long* retval);
 
    // IConnection

    [propget, id(3), helpstring("property ConnectionStatus")]
    HRESULT ConnectionStatus([out, retval] ConnectionStatus* retval);

    [propput, id(4), helpstring("property Host")]
    HRESULT Host([in] BSTR newValue);
    [propget, id(4), helpstring("property Host")]
    HRESULT Host([out, retval] BSTR* retval);

    [propput, id(5), helpstring("property Port")]
    HRESULT Port([in] long newValue);
    [propget, id(5), helpstring("property Port")]
    HRESULT Port([out, retval] long* retval);

    [propput, id(22), helpstring("property ProtocolFamilyPreference")]
    HRESULT ProtocolFamilyPreference([in] ProtocolFamily newValue);
    [propget, id(22), helpstring("property ProtocolFamilyPreference")]
    HRESULT ProtocolFamilyPreference([out, retval] ProtocolFamily* retval);

    [propget, id(91), helpstring("property ProtocolFamily")]
    HRESULT ProtocolFamily([out, retval] ProtocolFamily* retval);
 
    // IFTPConnection

    // TODO: rename to EnableLogin/EnableAuthentication
    [propput, id(122), helpstring("property Login")]
    HRESULT Login([in] VARIANT_BOOL newValue);
    [propget, id(122), helpstring("property Login")]
    HRESULT Login([out, retval] VARIANT_BOOL * retval);

    [propput, id(6), helpstring("property Username")]
    HRESULT Username([in] BSTR newValue);
    [propget, id(6), helpstring("property Username")]
    HRESULT Username([out, retval] BSTR* retval);

    [propput, id(7), helpstring("property Password")]
    HRESULT Password([in] BSTR newValue);
    [propget, id(7), helpstring("property Password")]
    HRESULT Password([out, retval] BSTR* retval);

    [propput, id(8), helpstring("property Protocol")]
    HRESULT Protocol([in] FTPProtocol newValue);
    [propget, id(8), helpstring("property Protocol")]
    HRESULT Protocol([out, retval] FTPProtocol* retval);

    [propput, id(9), helpstring("property PortMode")]
    HRESULT PortMode([in] PortMode newValue);
    [propget, id(9), helpstring("property PortMode")]
    HRESULT PortMode([out, retval] PortMode* retval);

    [propput, id(10), helpstring("property PortIP")]
    HRESULT PortIP([in] BSTR newValue);
    [propget, id(10), helpstring("property PortIP")]
    HRESULT PortIP([out, retval] BSTR* retval);

    // TODO: rename to UsePassiveMode
    [propput, id(11), helpstring("property Passive")]
    HRESULT Passive([in] VARIANT_BOOL newValue);
    [propget, id(11), helpstring("property Passive")]
    HRESULT Passive([out, retval] VARIANT_BOOL* retval);

    [propput, id(12), helpstring("property DataTransferType")]
    HRESULT DataTransferType([in] DataTransferType newValue);
    [propget, id(12), helpstring("property DataTransferType")]
    HRESULT DataTransferType([out, retval] DataTransferType* retval);
 
    [propput, id(13), helpstring("property DataProtection")]
    HRESULT DataProtection([in] DataProtection newValue);
    [propget, id(13), helpstring("property DataProtection")]
    HRESULT DataProtection([out, retval] DataProtection* retval);
 
    [propput, id(165), helpstring("property CommandProtection")]
    HRESULT CommandProtection([in] DataProtection newValue);
    [propget, id(165), helpstring("property CommandProtection")]
    HRESULT CommandProtection([out, retval] DataProtection* retval);

    [propput, id(106), helpstring("property PROTFallback")]
    HRESULT PROTFallback([in] VARIANT_BOOL newValue);
    [propget, id(106), helpstring("property PROTFallback")]
    HRESULT PROTFallback([out, retval] VARIANT_BOOL* retval);
 
    [propput, id(20), helpstring("property CodePage")]
    HRESULT CodePage([in] long newValue);
    [propget, id(20), helpstring("property CodePage")]
    HRESULT CodePage([out, retval] long* retval);

    [propput, id(21), helpstring("property PassiveMode")]
    HRESULT PassiveMode([in] PassiveMode newValue);
    [propget, id(21), helpstring("property PassiveMode")]
    HRESULT PassiveMode([out, retval] PassiveMode* retval);

    [propput, id(23), helpstring("property LimitLocalPortRange")]
    HRESULT LimitLocalPortRange([in] VARIANT_BOOL newValue);
    [propget, id(23), helpstring("property LimitLocalPortRange")]
    HRESULT LimitLocalPortRange([out, retval] VARIANT_BOOL* retval);

    [propput, id(24), helpstring("property UseMLSD")]
    HRESULT UseMLSD([in] VARIANT_BOOL newValue);
    [propget, id(24), helpstring("property UseMLSD")]
    HRESULT UseMLSD([out, retval] VARIANT_BOOL* retval);

    [propput, id(25), helpstring("property DataTransferMode")]
    HRESULT DataTransferMode([in] DataTransferMode newValue);
    [propget, id(25), helpstring("property DataTransferMode")]
    HRESULT DataTransferMode([out, retval] DataTransferMode* retval);

    [propput, id(26), helpstring("property LISTOption")]
    HRESULT LISTOption([in] long newValue);
    [propget, id(26), helpstring("property LISTOption")]
    HRESULT LISTOption([out, retval] long* retval);

    [propput, id(27), helpstring("property DataTransferSpeedLimit")]
    HRESULT DataTransferSpeedLimit([in] long newValue);
    [propget, id(27), helpstring("property DataTransferSpeedLimit")]
    HRESULT DataTransferSpeedLimit([out, retval] long* retval);

    [propput, id(89), helpstring("property SSCN")]
    HRESULT SSCN([in] VARIANT_BOOL newValue);
    [propget, id(89), helpstring("property SSCN")]
    HRESULT SSCN([out, retval] VARIANT_BOOL* retval);

    [propput, id(101), helpstring("property FeatureDiscovery")]
    HRESULT FeatureDiscovery([in] FeatureDiscoveryMode newValue);
    [propget, id(101), helpstring("property FeatureDiscovery")]
    HRESULT FeatureDiscovery([out, retval] FeatureDiscoveryMode* retval);

    [propput, id(116), helpstring("property FileBufferSize")]
    HRESULT FileBufferSize([in] long newValue);
    [propget, id(116), helpstring("property FileBufferSize")]
    HRESULT FileBufferSize([out, retval] long* retval);

    [propget, id(136), helpstring("property IdleKeepAlive")]
    HRESULT IdleKeepAlive([out, retval] VARIANT_BOOL* retval);
    [propput, id(136), helpstring("property IdleKeepAlive")]
    HRESULT IdleKeepAlive([in] VARIANT_BOOL newValue);

    [propget, id(137), helpstring("property TransferKeepAlive")]
    HRESULT TransferKeepAlive([out, retval] VARIANT_BOOL* retval);
    [propput, id(137), helpstring("property TransferKeepAlive")]
    HRESULT TransferKeepAlive([in] VARIANT_BOOL newValue);

    [propput, id(133), helpstring("property KeepAliveInterval")]
    HRESULT KeepAliveInterval([in] long newValue);
    [propget, id(133), helpstring("property KeepAliveInterval")]
    HRESULT KeepAliveInterval([out, retval] long *retval);

    [propput, id(162), helpstring("property ClientId")]
    HRESULT ClientId([in] IFTPClientId* newValue);
    [propget, id(162), helpstring("property ClientId")]
    HRESULT ClientId([out, retval] IFTPClientId** retval);

    [propput, id(98), helpstring("property HidePassword")]
    HRESULT HidePassword([in] VARIANT_BOOL newValue);
    [propget, id(98), helpstring("property HidePassword")]
    HRESULT HidePassword([out, retval] VARIANT_BOOL* retval);

    [propget, id(43), helpstring("property WorkingDirectory")]
    HRESULT WorkingDirectory([out, retval] BSTR* retval);

    [propget, id(102), helpstring("property PeerName")]
    HRESULT PeerName([out, retval] BSTR* retval);

    [propget, id(134), helpstring("property ServerState")]
    HRESULT ServerState([out, retval] IFTPServerState **retval);

    [propget, id(138), helpstring("property Proxy")]
    HRESULT Proxy([out, retval] IProxySettings** retval);

    // TODO: rename to ITlsSocket
    [propget, id(14), helpstring("property SSLSocketLayer")]
    HRESULT SSLSocketLayer([out, retval] ITlsSocket** retval);

    [propget, id(15), helpstring("property SocketSettings")]
    HRESULT SocketSettings([out, retval] ISocketSettings** retval);

    [propget, id(16), helpstring("property SpeedLimitSettings")]
    HRESULT SpeedLimitSettings([out, retval] ISpeedLimitSettings** retval);

    [propput, id(18), helpstring("property Logger")]
    HRESULT Logger([in] ILogger* logger);

    [propput, id(139), helpstring("property CompressionLevel")]
    HRESULT CompressionLevel([in] long newValue);
    [propget, id(139), helpstring("property CompressionLevel")]
    HRESULT CompressionLevel([out, retval] long* retval);

    [propget, id(47), helpstring("property LastReply")] HRESULT
    LastReply([out, retval] BSTR* retval);

    [propget, id(48), helpstring("property LastReplyCode")]
    HRESULT LastReplyCode([out, retval] long *retval);

    [propget, id(112), helpstring("property LastCommand")]
    HRESULT LastCommand([out, retval] BSTR* retval);

    [propget, id(51), helpstring("property LastError")]
    HRESULT LastError([out, retval] HRESULT* retval);

    [propget, id(160), helpstring("property LastDataConnectionError")]
    HRESULT LastDataConnectionError([out, retval] HRESULT* retval);

    [propget, id(55), helpstring("property LastTransferBytes")]
    HRESULT LastTransferBytes([out, retval] ULONGLONG *retval);

    [propget, id(56), helpstring("property LastTransferBytesLo")]
    HRESULT LastTransferBytesLo([out, retval] long *retval);

    [propget, id(108), helpstring("property LastTransferBytesHi")]
    HRESULT LastTransferBytesHi([out, retval] long *retval);

    [propget, id(57), helpstring("property LastTransferTime")]
    HRESULT LastTransferTime([out, retval] long *retval);

    [propget, id(58), helpstring("property LastTransferSpeed")]
    HRESULT LastTransferSpeed([out, retval] long *retval);

    [propput, id(93), helpstring("property PassiveAddress")]
    HRESULT PassiveAddress([in] BSTR newValue);
    [propget, id(93), helpstring("property PassiveAddress")]
    HRESULT PassiveAddress([out, retval] BSTR* retval);

    [propput, id(110), helpstring("property Account")]
    HRESULT Account([in] BSTR newValue);
    [propget, id(110), helpstring("property Account")]
    HRESULT Account([out, retval] BSTR* retval);

    [id(62), helpstring("method Abort")]
    HRESULT Abort();

    [id(92), helpstring("method Continue")]
    HRESULT Continue();
 
    // IFTPConnection
    [id(61), helpstring("method Close")]
    HRESULT Close();

    [id(63), helpstring("method Connect")]
    HRESULT Connect();

    [id(64), helpstring("method Disconnect")]
    HRESULT Disconnect();

    [id(65), helpstring("method ChangeDirectory")]
    HRESULT ChangeDirectory([in] BSTR directory);

    [id(147), helpstring("method UpdateWorkingDirectory")]
    HRESULT UpdateWorkingDirectory();

    [id(66), helpstring("method DownloadFile")]
    HRESULT DownloadFile([in] BSTR remoteFile, [in] BSTR localFile, [in] long startPositionLo, [in] long startPositionHi);
 
    [id(150), helpstring("method DownloadFromCommand")]
    HRESULT DownloadFromCommand([in] BSTR command, [in] VARIANT localFile, [in] long remoteStartPosLo, [in] long remoteStartPosHi);

    [id(123), helpstring("method DownloadFileEx")]
    HRESULT DownloadFileEx([in] BSTR remoteFile, [in] VARIANT localFile, [in] ULONGLONG startPosition, [in] ULONGLONG endPosition, [in] ITransferProgressEvents* progress);

    [id(68), helpstring("method UploadFile")]
    HRESULT UploadFile([in] BSTR localFile, [in] BSTR remoteFile, [in] long startPositionLo, [in] long startPositionHi);

    [id(124), helpstring("method UploadFileEx")]
    HRESULT UploadFileEx([in] VARIANT localFile, [in] BSTR remoteFile, [in] ULONGLONG startPosition, [in] ITransferProgressEvents* progress);

    [id(121), helpstring("method NewFile")]
    HRESULT NewFile([in] BSTR file);

    [id(69), helpstring("method ChangeDirectoryUp")]
    HRESULT ChangeDirectoryUp();

    [id(70), helpstring("method RenameFile")]
    HRESULT RenameFile([in] BSTR fileFrom, [in] BSTR fileTo);

    [id(71), helpstring("method DeleteFile")]
    HRESULT DeleteFile([in] BSTR file);

    [id(72), helpstring("method RenameDirectory")]
    HRESULT RenameDirectory([in] BSTR directoryFrom, [in] BSTR directoryTo);

    [id(73), helpstring("method RemoveDirectory")]
    HRESULT RemoveDirectory([in] BSTR directory);

    [id(74), helpstring("method Command")]
    HRESULT Command([in] BSTR command);

    [id(75), helpstring("method MakeDirectory")]
    HRESULT MakeDirectory([in] BSTR directory);

    [id(76), helpstring("method GetFileSize")]
    HRESULT GetFileSize([in] BSTR file, [out, retval] ULONGLONG* retval);

    [id(78), helpstring("method GetFileSize32")]
    HRESULT GetFileSize32([in] BSTR file, [out, retval] long* retval);

    [id(77), helpstring("method ReadDirectory")]
    HRESULT ReadDirectory([out, retval] IFTPItems** retval);
 
    [id(153), helpstring("method ReadDirectoryEx")]
    HRESULT ReadDirectoryEx([in] ITransferProgressEvents* progress, [out, retval] IFTPItems** retval);
 
    [id(118), helpstring("method ReadDirectoryFromCommand")]
    HRESULT ReadDirectoryFromCommand([in] BSTR command, [out, retval] IFTPItems** retval);

    [id(79), helpstring("method ReadDirectoryRaw")]
    HRESULT ReadDirectoryRaw([in] VARIANT localFile);

    [id(80), helpstring("method GetModifyTime")]
    HRESULT GetModifyTime([in] BSTR file, [out, retval] FILETIME* retval);

    [id(81), helpstring("method GetModifyTimeAsDate")]
    HRESULT GetModifyTimeAsDate([in] BSTR file, [out, retval] VARIANT* retval);
 
//  [id(139), helpstring("method GetItem")]
//  HRESULT GetItem([in] BSTR name, [out, retval] IFTPItem** retval);\
 
    [id(140), helpstring("method GetMLST")]
    HRESULT GetMLST([in] BSTR name, [out, retval] IFTPItem** retval);

    [id(141), helpstring("method Stat")]
    HRESULT Stat([in] BSTR name, [out, retval] IFTPItems** retval);

    [id(83), helpstring("method SetModifyTime")]
    HRESULT SetModifyTime([in] BSTR file, [in] FILETIME time);

    [id(85), helpstring("method SetModifyTimeAsDate")]
    HRESULT SetModifyTimeAsDate([in] BSTR file, [in] VARIANT date);

    [id(170), helpstring("method SetCreateTime")]
    HRESULT SetCreateTime([in] BSTR file, [in] FILETIME time);

    [id(171), helpstring("method SetCreateTimeAsDate")]
    HRESULT SetCreateTimeAsDate([in] BSTR file, [in] VARIANT date);

    [id(84), helpstring("method SetUnixPermissions")]
    HRESULT SetUnixPermissions([in] BSTR name, [in] long permissions);

    [id(86), helpstring("method GetFileHash")]
    HRESULT GetFileHash([in] HashAlgo algo, [in] BSTR file, [in] ULONGLONG start, [in] ULONGLONG length, [out, retval] BSTR* retval);

    [id(88), helpstring("method ClearCommandChannel")]
    HRESULT ClearCommandChannel();

    [id(90), helpstring("method InitializeTransfer")]
    HRESULT InitializeTransfer();

    [id(94), helpstring("method FXPDownloadFile")]
    HRESULT FXPDownloadFile([in] BSTR remoteFile, [in] ULONGLONG startPosition);

    [id(95), helpstring("method FXPUploadFile")]
    HRESULT FXPUploadFile([in] BSTR remoteFile, [in] ULONGLONG startPosition);

    [id(174), helpstring("method GetSpaceAvailable")]
    HRESULT GetSpaceAvailable([in] BSTR path, [out, retval] ISFTPSpaceAvailable** retval);
 
    [id(176), helpstring("method CopyFile")]
    HRESULT CopyFile([in] BSTR sourceFile, [in] BSTR destinationFile);

    [id(177), helpstring("method SetFileLogger")]
    HRESULT SetFileLogger([out, retval] IFileLogger** fileLogger);
};
 
[   object,
    uuid(DB80022E-14E3-4af0-B075-46C3889E15EB),    // IID_IFTPParser
    nonextensible,
    pointer_default(unique)
]
interface IFTPParser : IUnknown
{
    HRESULT Initialize([in] ParserFormat format);
    HRESULT ParseLine([in] LPCWSTR line, [out, retval] IFTPItem** item);
};

[   object,
    uuid(B1798D9B-1282-4A31-BCF3-75609768B745),    // IID_IFTPParserD
    oleautomation,
    nonextensible,
    helpstring("IFTPParserD Interface"),
    pointer_default(unique)
]
interface IFTPParserD : IDispatch
{
    [id(10), helpstring("method Initialize")]
    HRESULT Initialize([in] ParserFormat format);

    [id(11), helpstring("method ParseLine")]
    HRESULT ParseLine([in] BSTR line, [out, retval] IFTPItem** item);
};
 
[
    object,
    uuid(44ABDFAD-4F53-4CB3-8B68-3F70AB7943FB),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IFTPFXP Interface"),
    pointer_default(unique)
]
interface IFTPFXP : IDispatch
{
    [propput, id(3), helpstring("property Source")]
    HRESULT Source([in] IFTPConnection *newValue);
    [propget, id(3), helpstring("property Source")]
    HRESULT Source([out, retval] IFTPConnection** retval);

    [propput, id(4), helpstring("property Destination")]
    HRESULT Destination([in] IFTPConnection *newValue);
    [propget, id(4), helpstring("property Destination")]
    HRESULT Destination([out, retval] IFTPConnection** retval);

    [id(10), helpstring("method FXPFile")]
    HRESULT FXPFile([in] BSTR sourceFile, [in] BSTR destinationFile, [in] long startPositionLo, [in] long startPositionHi);
 
    [local] HRESULT FXPFileEx([in] LPCWSTR sourceFile, [in] LPCWSTR destinationFile, [in] ULONGLONG startPosition, [in] HANDLE cancelEvent);
};
 
typedef [v1_enum] enum SSHServerSoftware
{
    [helpstring("SSHServerSoftware ftpSSHServerSoftware Unknown")]      ftpSSHServerSoftwareUnknown = 0,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware VShell")]       ftpSSHServerSoftwareVShell = 1,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware SSHTectia")]    ftpSSHServerSoftwareSSHTectia = 2,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware OpenSSH")]  ftpSSHServerSoftwareOpenSSH = 3,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware Titan")]    ftpSSHServerSoftwareTitan = 4,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware GSFTPS")]   ftpSSHServerSoftwareGSFTPS = 5,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware WinSSHD")]  ftpSSHServerSoftwareWinSSHD = 6,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware WSFTP")]    ftpSSHServerSoftwareWSFTP = 7,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware FTPShell")] ftpSSHServerSoftwareFTPShell = 8,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware WeOnlyDo")] ftpSSHServerSoftwareWeOnlyDo = 9,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware PragmaFortressSSH")]    ftpSSHServerSoftwarePragmaFortressSSH = 10,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware JSCAPE")]   ftpSSHServerSoftwareJSCAPE = 11,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware CoreFTP")]  ftpSSHServerSoftwareCoreFTP = 12,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware OpenVMS")]  ftpSSHServerSoftwareOpenVMS = 13,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware FSecure")]  ftpSSHServerSoftwareFSecure = 14,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware SSHcomOld")]    ftpSSHServerSoftwareSSHcomOld = 15,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware Sun")]  ftpSSHServerSoftwareSun = 16,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware ServU")]    ftpSSHServerSoftwareServU = 17,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware dropbear")] ftpSSHServerSoftwaredropbear = 18,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware ReflectionForSecureIT")]    ftpSSHServerSoftwareReflectionForSecureIT = 19,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware SSHTools")] ftpSSHServerSoftwareSSHTools = 20,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware GXSSSHD")]  ftpSSHServerSoftwareGXSSSHD = 21,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware ProFTPD")]  ftpSSHServerSoftwareProFTPD = 22,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware zFTPServer")]   ftpSSHServerSoftwarezFTPServer = 23,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware Maverick")] ftpSSHServerSoftwareMaverick = 24,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware SecureTransport")]  ftpSSHServerSoftwareSecureTransport = 25,
    [helpstring("SSHServerSoftware ftpSSHServerSoftware Xlight")]   ftpSSHServerSoftwareXlight = 26
} SSHServerSoftware;
 
typedef [v1_enum] enum SFTPStatus
{
// --- General Status ---

    [helpstring("SFTPStatus ftpSFTPStatus Ok")]     
    ftpSFTPStatusOk = 0,

    [helpstring("SFTPStatus ftpSFTPStatus EOF")]        
    ftpSFTPStatusEOF = 1,

    [helpstring("SFTPStatus ftpSFTPStatus Failure")]        
    ftpSFTPStatusFailure = 4,

    [helpstring("SFTPStatus ftpSFTPStatus BadMessage")]     
    ftpSFTPStatusBadMessage = 5,

    [helpstring("SFTPStatus ftpSFTPStatus OpUnsupported")]      
    ftpSFTPStatusOpUnsupported = 8,
 
    // --- Connection State (Client Side) ---

    [helpstring("SFTPStatus ftpSFTPStatus NoConnection")]       
    ftpSFTPStatusNoConnection = 6,

    [helpstring("SFTPStatus ftpSFTPStatus ConnectionLost")]     
    ftpSFTPStatusConnectionLost = 7,
 
    // --- File & Path Existence ---

    [helpstring("SFTPStatus ftpSFTPStatus NoSuchFile")]     
    ftpSFTPStatusNoSuchFile = 2,

    [helpstring("SFTPStatus ftpSFTPStatus NoSuchPath")]     
    ftpSFTPStatusNoSuchPath = 10,

    [helpstring("SFTPStatus ftpSFTPStatus FileAlreadyExists")]      
    ftpSFTPStatusFileAlreadyExists = 11,

    [helpstring("SFTPStatus ftpSFTPStatus NotADirectory")]      
    ftpSFTPStatusNotADirectory = 19,

    [helpstring("SFTPStatus ftpSFTPStatus FileIsADirectory")]       
    ftpSFTPStatusFileIsADirectory = 24,

    [helpstring("SFTPStatus ftpSFTPStatus InvalidFilename")]        
    ftpSFTPStatusInvalidFilename = 20,

    [helpstring("SFTPStatus ftpSFTPStatus LinkLoop")]       
    ftpSFTPStatusLinkLoop = 21,
 
    // --- Permissions & Access ---

    [helpstring("SFTPStatus ftpSFTPStatus PermissionDenied")]       
    ftpSFTPStatusPermissionDenied = 3,

    [helpstring("SFTPStatus ftpSFTPStatus WriteProtect")]       
    ftpSFTPStatusWriteProtect = 12,

    [helpstring("SFTPStatus ftpSFTPStatus CannotDelete")]       
    ftpSFTPStatusCannotDelete = 22,

    [helpstring("SFTPStatus ftpSFTPStatus DirNotEmpty")]        
    ftpSFTPStatusDirNotEmpty = 18,
 
    // --- Handles & Parameters ---

    [helpstring("SFTPStatus ftpSFTPStatus InvalidHandle")]      
    ftpSFTPStatusInvalidHandle = 9,

    [helpstring("SFTPStatus ftpSFTPStatus InvalidParameter")]       
    ftpSFTPStatusInvalidParameter = 23,
 
    // --- Storage & Quotas (SFTP v6) ---

    [helpstring("SFTPStatus ftpSFTPStatus NoMedia")]        
    ftpSFTPStatusNoMedia = 13,

    [helpstring("SFTPStatus ftpSFTPStatus NoSpaceOnFilesystem")]        
    ftpSFTPStatusNoSpaceOnFilesystem = 14,

    [helpstring("SFTPStatus ftpSFTPStatus QuotaExceeded")]      
    ftpSFTPStatusQuotaExceeded = 15,
 
    // --- Advanced Locking & Principals (SFTP v6) ---

    [helpstring("SFTPStatus ftpSFTPStatus UnknownPrincipal")]       
    ftpSFTPStatusUnknownPrincipal = 16,

    [helpstring("SFTPStatus ftpSFTPStatus LocalConflict")]      
    ftpSFTPStatusLocalConflict = 17,

    [helpstring("SFTPStatus ftpSFTPStatus ByteRangeLockConflict")]      
    ftpSFTPStatusByteRangeLockConflict = 25,

    [helpstring("SFTPStatus ftpSFTPStatus ByteRangeLockRefused")]       
    ftpSFTPStatusByteRangeLockRefused = 26,

    [helpstring("SFTPStatus ftpSFTPStatus DeletePending")]      
    ftpSFTPStatusDeletePending = 27,

    [helpstring("SFTPStatus ftpSFTPStatus FileCorrupt")]        
    ftpSFTPStatusFileCorrupt = 28,

    [helpstring("SFTPStatus ftpSFTPStatus OwnerInvalid")]       
    ftpSFTPStatusOwnerInvalid = 29,

    [helpstring("SFTPStatus ftpSFTPStatus GroupInvalid")]       
    ftpSFTPStatusGroupdInvalid = 30,

    [helpstring("SFTPStatus ftpSFTPStatus NoMatchingByteRangeLock")]        
    ftpSFTPStatusNoMatchingByteRangeLock = 31
} SFTPStatus;
 
// Forward declaration
interface IKey;
 
[
    object,
    uuid(6807C542-6AE2-4E14-AF12-84C2E1A39E46),
    dual,
    nonextensible,
    helpstring("ISFTPStatVFS Interface"),
    pointer_default(unique)
]
interface ISFTPStatVFS : IDispatch
{
    [propget, id(1), helpstring("property bsize")] HRESULT bsize([out, retval] ULONGLONG* retval);

    [propget, id(2), helpstring("property frsize")] HRESULT frsize([out, retval] ULONGLONG* retval);

    [propget, id(3), helpstring("property blocks")] HRESULT blocks([out, retval] ULONGLONG* retval);

    [propget, id(4), helpstring("property bfree")] HRESULT bfree([out, retval] ULONGLONG* retval);

    [propget, id(5), helpstring("property bavail")] HRESULT bavail([out, retval] ULONGLONG* retval);

    [propget, id(6), helpstring("property files")] HRESULT files([out, retval] ULONGLONG* retval);

    [propget, id(7), helpstring("property ffree")] HRESULT ffree([out, retval] ULONGLONG* retval);

    [propget, id(8), helpstring("property favail")] HRESULT favail([out, retval] ULONGLONG* retval);

    [propget, id(9), helpstring("property fsid")] HRESULT fsid([out, retval] ULONGLONG* retval);

    [propget, id(10), helpstring("property flag")] HRESULT flag([out, retval] ULONGLONG* retval);

    [propget, id(11), helpstring("property namemax")] HRESULT namemax([out, retval] ULONGLONG* retval);
};

[
    object,
    uuid(D117CF34-177D-49AB-BD19-46DC87857947),
    dual,
    nonextensible,
    helpstring("ISFTPVendorId Interface"),
    pointer_default(unique)
]
interface ISFTPVendorId : IDispatch
{
    [propput, id(1), helpstring("property VendorName")] 
    HRESULT VendorName([in] BSTR newValue);
    [propget, id(1), helpstring("property VendorName")] 
    HRESULT VendorName([out, retval] BSTR *retval);

    [propput, id(2), helpstring("property ProductName")] 
    HRESULT ProductName([in] BSTR newValue);
    [propget, id(2), helpstring("property ProductName")] 
    HRESULT ProductName([out, retval] BSTR *retval);

    [propput, id(3), helpstring("property ProductVersion")] 
    HRESULT ProductVersion([in] BSTR newValue);
    [propget, id(3), helpstring("property ProductVersion")] 
    HRESULT ProductVersion([out, retval] BSTR *retval);

    [propput, id(4), helpstring("property ProductBuild")] 
    HRESULT ProductBuild([in] ULONGLONG newValue);
    [propget, id(4), helpstring("property ProductBuild")] 
    HRESULT ProductBuild([out, retval] ULONGLONG *retval);
};
 
[
    object,
    uuid(F8D2F36D-B32D-45EF-965E-2DA153B3D523),
    dual,
    nonextensible,
    helpstring("ISFTPServerState Interface"),
    pointer_default(unique)
]
interface ISFTPServerState : IDispatch
{
    [propget, id(1), helpstring("property EOL")] HRESULT EOL([out, retval] BSTR *retval);

    [propget, id(3), helpstring("property VendorId")] HRESULT VendorId([out, retval] ISFTPVendorId **retval);

    [id(100), helpstring("method IsExtension")] HRESULT IsExtension([in] BSTR extension, [out, retval] VARIANT_BOOL *retval);
};
 
typedef [v1_enum] enum GSSAPIMethod
{
    [helpstring("GSSAPIMethod Unknown")] 
    ftpGSSAPIMethodUnknown = 0,

    [helpstring("GSSAPIMethod MITKerberos")]    
    ftpGSSAPIMethodMITKerberos = 1,

    [helpstring("GSSAPIMethod MicrosoftKerberos")]  
    ftpGSSAPIMethodMicrosoftKerberos = 2
} GSSAPIMethod;
 
[
    object,
    uuid(B79FF913-446B-442B-A541-049178F39605),
    dual,
    nonextensible,
    helpstring("ISFTPSpaceAvailable Interface"),
    pointer_default(unique)
]
interface ISFTPSpaceAvailable : IDispatch
{
    [propget, id(1), helpstring("property BytesOnDevice")] 
    HRESULT BytesOnDevice([out, retval] ULONGLONG* retval);

    [propget, id(2), helpstring("property UnusedBytesOnDevice")] 
    HRESULT UnusedBytesOnDevice([out, retval] ULONGLONG* retval);

    [propget, id(3), helpstring("property BytesAvailableToUser")] 
    HRESULT BytesAvailableToUser([out, retval] ULONGLONG* retval);

    [propget, id(4), helpstring("property UnusedBytesAvailableToUser")] 
    HRESULT UnusedBytesAvailableToUser([out, retval] ULONGLONG* retval);

    [propget, id(5), helpstring("property BytesPerAllocationUnit")] 
    HRESULT BytesPerAllocationUnit([out, retval] long* retval);
};

[
    object,
    uuid(DEE0FBC7-4879-4CA5-83D9-8BF827D6A1D7),
    dual,
    nonextensible,
    helpstring("ISSHConnectionInfo Interface"),
    pointer_default(unique)
]
interface ISSHConnectionInfo : IDispatch
{
    [propget, id(1), helpstring("property KeyExchangeAlgorithm")] HRESULT KeyExchangeAlgorithm([out, retval] KeyExchange* retval);

    [propget, id(2), helpstring("property KeyExchangeHashAlgorithm")] HRESULT KeyExchangeHashAlgorithm([out, retval] HashAlgo* retval);
 
    [propget, id(3), helpstring("property ClientToServerEncryption")] HRESULT ClientToServerEncryption([out, retval] Encryption* retval);

    [propget, id(4), helpstring("property ServerToClientEncryption")] HRESULT ServerToClientEncryption([out, retval] Encryption* retval);

    [propget, id(5), helpstring("property ClientToServerCompression")] HRESULT ClientToServerCompression([out, retval] SSHCompression* retval);

    [propget, id(6), helpstring("property ServerToClientCompression")] HRESULT ServerToClientCompression([out, retval] SSHCompression* retval);

    [propget, id(7), helpstring("property ClientToServerMAC")] HRESULT ClientToServerMAC([out, retval] HMAC* retval);

    [propget, id(8), helpstring("property ServerToClientMAC")] HRESULT ServerToClientMAC([out, retval] HMAC* retval);

    [propget, id(9), helpstring("property HostKeyAlgorithm")] HRESULT HostKeyAlgorithm([out, retval] SSHPublicKeyAlgo* retval);
};

[
    object,
    uuid(F63AF79B-4567-40B2-84A9-07F823750AC6),
    dual,
    nonextensible,
    helpstring("ISSHServerState Interface"),
    pointer_default(unique)
]
interface ISSHServerState : IDispatch
{
    [propget, id(26), helpstring("property ServerSoftware")] HRESULT ServerSoftware([out, retval] SSHServerSoftware* retval);

    [propget, id(59), helpstring("property OperatingSystem")] HRESULT OperatingSystem([out, retval] OperatingSystem *retval);

    [propget, id(27), helpstring("property RemoteId")] HRESULT RemoteId([out, retval] BSTR* retval);
};
 
interface ISFTPConnection;
 
[
    object,
    uuid(EAFA9ED3-6D11-44F6-B28D-EEA199508903),
    dual,
    nonextensible,
    helpstring("ISSHConnection Interface"),
    pointer_default(unique)
]
interface ISSHConnection : IDispatch
{
    // OperationHandler
    [propget, id(2), helpstring("property Busy")]
    HRESULT Busy([out, retval] VARIANT_BOOL* retval);

    [propget, id(3), helpstring("property ConnectionInfo")]
    HRESULT ConnectionInfo([out, retval] ISSHConnectionInfo** retval);

    [propget, id(14), helpstring("property ConnectionStatus")]
    HRESULT ConnectionStatus([out, retval] ConnectionStatus* retval);

    [propput, id(117), helpstring("property UseMessageLoop")]
    HRESULT UseMessageLoop([in] VARIANT_BOOL newValue);
    [propget, id(117), helpstring("property UseMessageLoop")]
    HRESULT UseMessageLoop([out, retval] VARIANT_BOOL* retval);

    [propput, id(4), helpstring("property Host")]
    HRESULT Host([in] BSTR newValue);
    [propget, id(4), helpstring("property Host")]
    HRESULT Host([out, retval] BSTR* retval);

    [propput, id(5), helpstring("property Port")]
    HRESULT Port([in] long newValue);
    [propget, id(5), helpstring("property Port")]
    HRESULT Port([out, retval] long* retval);

    [propget, id(20), helpstring("property ProtocolFamily")]
    HRESULT ProtocolFamily([out, retval] ProtocolFamily* retval);

    [propput, id(22), helpstring("property ProtocolFamilyPreference")]
    HRESULT ProtocolFamilyPreference([in] ProtocolFamily newValue);
    [propget, id(22), helpstring("property ProtocolFamilyPreference")]
    HRESULT ProtocolFamilyPreference([out, retval] ProtocolFamily* retval);
 
    // ISSHConnection

    [propput, id(6), helpstring("property Username")]
    HRESULT Username([in] BSTR newValue);
    [propget, id(6), helpstring("property Username")]
    HRESULT Username([out, retval] BSTR* retval);

    [propput, id(7), helpstring("property Password")]
    HRESULT Password([in] BSTR newValue);
    [propget, id(7), helpstring("property Password")]
    HRESULT Password([out, retval] BSTR* retval);

    [propput, id(8), helpstring("property ClientId")]
    HRESULT ClientId([in] BSTR newValue);
    [propget, id(8), helpstring("property ClientId")]
    HRESULT ClientId([out, retval] BSTR* retval);

    [propput, id(19), helpstring("property Timeout")]
    HRESULT Timeout([in] long newValue);
    [propget, id(19), helpstring("property Timeout")]
    HRESULT Timeout([out, retval] long* retval);

    [propput, id(32), helpstring("property CompressionLevel")]
    HRESULT CompressionLevel([in] long newValue);
    [propget, id(32), helpstring("property CompressionLevel")]
    HRESULT CompressionLevel([out, retval] long* retval);

    [propput, id(10), helpstring("property PrivateKey")]
    HRESULT PrivateKey([in] IKey *newValue);
    [propget, id(10), helpstring("property PrivateKey")]
    HRESULT PrivateKey([out, retval] IKey** retval);

    [propput, id(40), helpstring("property AgentKeyBlob")]
    HRESULT AgentKeyBlob([in] VARIANT* newValue);
    [propget, id(40), helpstring("property AgentKeyBlob")]
    HRESULT AgentKeyBlob([out, retval] VARIANT* retval);    

    [propput, id(11), helpstring("property Authentications")]
    HRESULT Authentications([in] VARIANT* newValue);
    [propget, id(11), helpstring("property Authentications")]
    HRESULT Authentications([out, retval] VARIANT* retval);

    [propput, id(12), helpstring("property Encryptions")]
    HRESULT Encryptions([in] VARIANT* newValue);
    [propget, id(12), helpstring("property Encryptions")]
    HRESULT Encryptions([out, retval] VARIANT* retval);

    [propput, id(13), helpstring("property MACs")]
    HRESULT MACs([in] VARIANT* newValue);
    [propget, id(13), helpstring("property MACs")]
    HRESULT MACs([out, retval] VARIANT* retval);

    [propput, id(9), helpstring("property Compressions")]
    HRESULT Compressions([in] VARIANT* newValue);
    [propget, id(9), helpstring("property Compressions")]
    HRESULT Compressions([out, retval] VARIANT* retval);

    [propput, id(25), helpstring("property KeyExchanges")]
    HRESULT KeyExchanges([in] VARIANT* newValue);
    [propget, id(25), helpstring("property KeyExchanges")]
    HRESULT KeyExchanges([out, retval] VARIANT* retval);

    [propput, id(28), helpstring("property ClientHostKey")]
    HRESULT ClientHostKey([in] IKey *newValue);
    [propget, id(28), helpstring("property ClientHostKey")]
    HRESULT ClientHostKey([out, retval] IKey** retval);

    [propput, id(29), helpstring("property ClientHostname")]
    HRESULT ClientHostname([in] BSTR newValue);
    [propget, id(29), helpstring("property ClientHostname")]
    HRESULT ClientHostname([out, retval] BSTR* retval);

    [propget, id(30), helpstring("property ServerHostKey")]
    HRESULT ServerHostKey([out, retval] IKey** retval);

    [propput, id(33), helpstring("property KeepAliveInterval")]
    HRESULT KeepAliveInterval([in] long newValue);
    [propget, id(33), helpstring("property KeepAliveInterval")]
    HRESULT KeepAliveInterval([out, retval] long* retval);

    [propget, id(31), helpstring("property Proxy")]
    HRESULT Proxy([out, retval] IProxySettings** retval);

    [propput, id(18), helpstring("property Logger")]
    HRESULT Logger([in] ILogger* logger);

    [propput, id(171), helpstring("property Languages")]
    HRESULT Languages([in] VARIANT* newValue);
    [propget, id(171), helpstring("property Languages")]
    HRESULT Languages([out, retval] VARIANT* retval);

    [propput, id(172), helpstring("property ServerHostKeyAlgorithms")]
    HRESULT ServerHostKeyAlgorithms([in] VARIANT* newValue);
    [propget, id(172), helpstring("property ServerHostKeyAlgorithms")]
    HRESULT ServerHostKeyAlgorithms([out, retval] VARIANT* retval);

    [propput, id(173), helpstring("property GSSAPIMethod")]
    HRESULT GSSAPIMethod([in] GSSAPIMethod newValue);
    [propget, id(173), helpstring("property GSSAPIMethod")]
    HRESULT GSSAPIMethod([out, retval] GSSAPIMethod* retval);

    [propput, id(175), helpstring("property UsePasswordForKeyboardInteractive")]
    HRESULT UsePasswordForKeyboardInteractive([in] VARIANT_BOOL newValue);
    [propget, id(175), helpstring("property UsePasswordForKeyboardInteractive")]
    HRESULT UsePasswordForKeyboardInteractive([out, retval] VARIANT_BOOL* retval);

    [propget, id(174), helpstring("property ServerState")]
    HRESULT ServerState([out, retval] ISSHServerState** retval);

    [propget, id(15), helpstring("property SocketSettings")]
    HRESULT SocketSettings([out, retval] ISocketSettings** retval);

    [propget, id(16), helpstring("property SpeedLimitSettings")]
    HRESULT SpeedLimitSettings([out, retval] ISpeedLimitSettings** retval);

    [id(61), helpstring("method Close")]
    HRESULT Close();

    [id(62), helpstring("method Abort")]
    HRESULT Abort();

    [id(63), helpstring("method Connect")]
    HRESULT Connect();

    [id(64), helpstring("method Disconnect")]
    HRESULT Disconnect();

    [id(65), helpstring("method CreateSFTPConnection")]
    HRESULT CreateSFTPConnection([out, retval] ISFTPConnection **retval);
 
    HRESULT SendPacket([in, size_is(length)] byte* data, [in] long length);

    [id(177), helpstring("method SetFileLogger")]
    HRESULT SetFileLogger([out, retval] IFileLogger** fileLogger);
};
 
[
    object,
    uuid(AA8FBBFD-22DF-41EF-83D0-5ECDB6BD47E6),
    oleautomation,
    dual,
    nonextensible,
    helpstring("ISFTPConnection Interface"),
    pointer_default(unique)
]
interface ISFTPConnection : IDispatch
{
    // Connection
    [propget, id(2), helpstring("property Busy")]
    HRESULT Busy([out, retval] VARIANT_BOOL* retval);

    [propput, id(117), helpstring("property UseMessageLoop")]
    HRESULT UseMessageLoop([in] VARIANT_BOOL newValue);
    [propget, id(117), helpstring("property UseMessageLoop")]
    HRESULT UseMessageLoop([out, retval] VARIANT_BOOL* retval);

    [propput, id(19), helpstring("property Timeout")]
    HRESULT Timeout([in] long newValue);
    [propget, id(19), helpstring("property Timeout")]
    HRESULT Timeout([out, retval] long* retval);
 
    // SFTP

    [propget, id(1), helpstring("property SSHConnection")]
    HRESULT SSHConnection([out, retval] ISSHConnection** retval);

    [propput, id(24), helpstring("property ProtocolVersionPreference")]
    HRESULT ProtocolVersionPreference([in] long newValue);
    [propget, id(24), helpstring("property ProtocolVersionPreference")]
    HRESULT ProtocolVersionPreference([out, retval] long* retval);

    [propput, id(182), helpstring("property SFTPServerCommand")]
    HRESULT SFTPServerCommand([in] BSTR newValue);
    [propget, id(182), helpstring("property SFTPServerCommand")]
    HRESULT SFTPServerCommand([out, retval] BSTR* retval);

    [propput, id(183), helpstring("property ServerLineTerminator")]
    HRESULT ServerLineTerminator([in] BSTR newValue);
    [propget, id(183), helpstring("property ServerLineTerminator")]
    HRESULT ServerLineTerminator([out, retval] BSTR* retval);

    [propget, id(4), helpstring("property ProtocolVersion")]
    HRESULT ProtocolVersion([out, retval] long* retval);

    [propget, id(3), helpstring("property Status")]
    HRESULT Status([out, retval] SFTPConnectionStatus* retval);

    [propget, id(181), helpstring("property VendorId")]
    HRESULT VendorId([out, retval] ISFTPVendorId **retval);
    [propput, id(181), helpstring("property VendorId")]
    HRESULT VendorId([in] ISFTPVendorId *newValue);

    [propput, id(53), helpstring("property Logger")]
    HRESULT Logger([in] ILogger* logger);

    [propget, id(54), helpstring("property LastStatusCode")]
    HRESULT LastStatusCode([out, retval] SFTPStatus* retval);

    [propget, id(50), helpstring("property LastStatusMessage")]
    HRESULT LastStatusMessage([out, retval] BSTR* retval);

    [propget, id(14), helpstring("property LastTransferBytes")]
    HRESULT LastTransferBytes([out, retval] ULONGLONG* retval);

    [propget, id(15), helpstring("property LastTransferBytesLo")]
    HRESULT LastTransferBytesLo([out, retval] long* retval);

    [propget, id(16), helpstring("property LastTransferBytesHi")]
    HRESULT LastTransferBytesHi([out, retval] long* retval);

    [propget, id(17), helpstring("property LastTransferTime")]
    HRESULT LastTransferTime([out, retval] long *retval);

    [propget, id(18), helpstring("property LastTransferSpeed")]
    HRESULT LastTransferSpeed([out, retval] long *retval);

    [propput, id(37), helpstring("property CodePage")]
    HRESULT CodePage([in] long newValue);
    [propget, id(37), helpstring("property CodePage")]
    HRESULT CodePage([out, retval] long* retval);

    [propget, id(170), helpstring("property ServerState")]
    HRESULT ServerState([out, retval] ISFTPServerState **retval);

    [id(61), helpstring("method Close")]
    HRESULT Close();

    [id(62), helpstring("method Abort")]
    HRESULT Abort();

    [id(63), helpstring("method Connect")]
    HRESULT Connect();

    [id(64), helpstring("method Disconnect")]
    HRESULT Disconnect();

    [id(81), helpstring("method NewFile")]
    HRESULT NewFile([in] BSTR remoteFile);

    [id(123), helpstring("method DownloadFile")]
    HRESULT DownloadFile([in] BSTR remoteFile, [in] VARIANT localFile, [in] DataTransferType transferType, [in] long startPositionLo, [in] long startPositionHi);

    [id(146), helpstring("method DownloadFileEx")]
    HRESULT DownloadFileEx([in] BSTR remoteFile, [in] VARIANT localFile, [in] DataTransferType transferType, [in] ULONGLONG startPosition, [in] ULONGLONG endPosition, [in] long flags, [in] ITransferProgressEvents* progress);

    [id(124), helpstring("method UploadFile")] 
    HRESULT UploadFile([in] VARIANT localFile, [in] BSTR remoteFile, [in] DataTransferType transferType, [in] long startPositionLo, [in] long startPositionHi);

    [id(125), helpstring("method UploadFileEx")]
    HRESULT UploadFileEx([in] VARIANT localFile, [in] BSTR remoteFile, [in] DataTransferType transferType, [in] ULONGLONG startPosition, [in] ITransferProgressEvents* progress);

    [id(70), helpstring("method Rename")]
    HRESULT Rename([in] BSTR oldPath, [in] BSTR newPath, [in] long flags);

    [id(71), helpstring("method RemoveFile")]
    HRESULT RemoveFile([in] BSTR file);

    [id(73), helpstring("method RemoveDirectory")]
    HRESULT RemoveDirectory([in] BSTR directory);

    [id(75), helpstring("method MakeDirectory")]
    HRESULT MakeDirectory([in] BSTR directory);

    [id(77), helpstring("method ReadDirectory")]
    HRESULT ReadDirectory([in] BSTR directory, [out, retval] IFTPItems** retval);

    [id(78), helpstring("method ReadDirectoryEx")]
    HRESULT ReadDirectoryEx([in] BSTR directory, [in] ITransferProgressEvents* progress, [out, retval] IFTPItems** retval);

    [id(120), helpstring("method RealPath")] 
    HRESULT RealPath([in] BSTR original, [out, retval] BSTR* retval);

    [id(121), helpstring("method RealPathEx")]
    HRESULT RealPathEx([in] BSTR original, [in] long flags, [in] BSTR component, [out, retval] BSTR* retval);

    [id(133), helpstring("method Stat")]
    HRESULT Stat([in] BSTR path, [in] long flags, [out, retval] IFTPItem** retval);

    [id(135), helpstring("method LStat")]
    HRESULT LStat([in] BSTR path, [in] long flags, [out, retval] IFTPItem** retval);

    [id(134), helpstring("method StatEx")]
    HRESULT StatEx([in] BSTR path, [in] long flags, VARIANT_BOOL followLink, [out, retval] IFTPItem** retval);

    [id(136), helpstring("method SetStat")]
    HRESULT SetStat([in] BSTR path, [in] IFTPItem* item);

    [id(140), helpstring("method ReadLink")]
    HRESULT ReadLink([in] BSTR path, [out, retval] BSTR* retval);

    [id(141), helpstring("method Link")]
    HRESULT Link([in] BSTR path, [in] BSTR linkPoint, [in] VARIANT_BOOL symbolicLink);

    [id(142), helpstring("method StatVFS")]
    HRESULT StatVFS([in] BSTR path, [out,retval] ISFTPStatVFS** retval);

    [id(168), helpstring("method GetFileHash")]
    HRESULT GetFileHash([in] HashAlgo algo, [in] BSTR path, [in] ULONGLONG offset, [in] ULONGLONG length, [out, retval] ISFTPExtendedCheckFileResult** retval);

    [id(174), helpstring("method GetSpaceAvailable")]
    HRESULT GetSpaceAvailable([in] BSTR path, [out, retval] ISFTPSpaceAvailable** retval);

    [id(176), helpstring("method CopyFile")]
    HRESULT CopyFile([in] BSTR sourceFile, [in] BSTR destinationFile, [in] VARIANT_BOOL overwrite);

    [id(177), helpstring("method SetFileLogger")]
    HRESULT SetFileLogger([out, retval] IFileLogger** fileLogger);
};
 
[
    object,
    uuid(F15D7259-E281-4F1B-8AA0-492AA3BDB7D5),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IOpenSSLKey Interface"),
    pointer_default(unique)
]
interface IOpenSSLKey : IKey
{
    [id(110), helpstring("method Generate")] HRESULT Generate([in] long nid, [in] long bits);
};
 
typedef [v1_enum] enum KeyFileFormat
{
    [helpstring("KeyFileFormat ftpKeyFileFormat Unknown")]              ftpKeyFileFormatUnknown = 0,
    [helpstring("KeyFileFormat ftpKeyFileFormat PKCS8")]                ftpKeyFileFormatPKCS8 = 1, 
    [helpstring("KeyFileFormat ftpKeyFileFormat PKCS12")]               ftpKeyFileFormatPKCS12 = 2, 
    [helpstring("KeyFileFormat ftpKeyFileFormat VanDyke")]              ftpKeyFileFormatVanDyke = 3, 
    [helpstring("KeyFileFormat ftpKeyFileFormat SSH")]                  ftpKeyFileFormatSSH = 4, 
    [helpstring("KeyFileFormat ftpKeyFileFormat OpenSSL")]              ftpKeyFileFormatOpenSSL = 5, 
    [helpstring("KeyFileFormat ftpKeyFileFormat Putty")]                ftpKeyFileFormatPutty = 6, 
    [helpstring("KeyFileFormat ftpKeyFileFormat OpenSSH")]              ftpKeyFileFormatOpenSSH = 7 
} KeyFileFormat;
 
[
    object,
    uuid(9B3D1FFA-EFBD-408B-AA81-B9B186138E24),
    oleautomation,
    dual,
    nonextensible,
    helpstring("IKeyManager Interface"),
    pointer_default(unique)
]
interface IKeyManager : IDispatch
{
    [id(1), helpstring("method LoadFile")] HRESULT LoadFile([in] BSTR file, [in] BSTR password, [out, retval] IKey** retval);

    [id(2), helpstring("method SaveFile")] HRESULT SaveFile([in] KeyFileFormat fileFormat, [in] IKey* key, [in] KeyType keyType, [in] BSTR file, [in] BSTR password);

    [id(3), helpstring("method LoadFromCertificateStore")] HRESULT LoadFromCertificateStore([in] BSTR thumbprint, [out, retval] IKey** retval);
};
 
[   
    uuid(1975424E-6927-40b2-A479-DE92310E8944),    // IID_IConnection
    pointer_default(unique)
]
interface IConnection : IUnknown
{
    [propget] HRESULT ConnectionStatus([out, retval] ConnectionStatus* retval); 
}
 
[
    object,
    uuid(2314C692-2C8A-4168-BB4B-DC26D525A1AE),
    nonextensible,
    pointer_default(unique)
]
interface IAES128CTRWriteStream : IUnknown
{
    HRESULT SetKey([in, size_is(keyLength)] byte* key, [in] ULONG keyLength);
};
 
[
    object,
    uuid(324D5D60-31E1-4D59-887F-96B93BAC3B2B),
    nonextensible,
    pointer_default(unique)
]
interface IAES128CTRReadStream : IUnknown
{
    HRESULT SetKey([in, size_is(keyLength)] byte* key, [in] ULONG keyLength);
};
 
[
    object,
    uuid(14FCCC7F-E60D-4E08-A0D8-B4E01823223D),
    nonextensible,
    pointer_default(unique)
]
interface IHashProgress : IUnknown
{
    HRESULT OnProgress(ULONGLONG chunk);
};
 
[
    object,
    uuid(AC19E8BE-AFFB-4AD4-954E-EDED75F2379E),
    dual,
    oleautomation,
    nonextensible,
    helpstring("ICryptoHash Interface"),
    pointer_default(unique)
]
interface ICryptoHash : IDispatch
{
    [propget, id(1), helpstring("property Type")] HRESULT Type([out, retval] HashAlgo* retval);
 
    [id(10), helpstring("method Initialize")] HRESULT Initialize(HashAlgo hashtype);
    [id(12), helpstring("method ReInitialize")] HRESULT ReInitialize();
    [id(13), helpstring("method GetSize")] HRESULT GetSize([out, retval] long *retval);
    [id(14), helpstring("method AddBSTR")] HRESULT AddBSTR([in] BSTR bstr);
    [id(22), helpstring("method AddBlob")] HRESULT AddBlob([in, size_is(cbBlob)] const byte* pbBlob, UINT cbBlob);
    [id(15), helpstring("method AddFile")] HRESULT AddFile([in] VARIANT var);
    [id(11), helpstring("method AddStream")] HRESULT AddStream([in] IStream* stream, [in] ULONGLONG length, [in] IHashProgress* progress);
    [id(16), helpstring("method GetValue")] HRESULT GetValue([out, retval] VARIANT *retval);
    [id(17), helpstring("method CompareStringValue")] HRESULT CompareStringValue([in] BSTR value1, [in] BSTR value2, [out, retval] long *retval);
    [id(19), helpstring("method GetValueAsString")] HRESULT GetValueAsString([out, retval] BSTR *retval);
    HRESULT GetValueEx([out, size_is(*valueLength)] byte* value, [in, out] ULONG* valueLength);
};
 
[
    object,
    uuid(9E58A1EB-F70E-4FA4-A6FD-F6DB4F19EE5F),
    nonextensible,
    pointer_default(unique)
]
interface IParserWriteStream : IUnknown
{
    [propput] HRESULT Format([in] ParserFormat newValue);
    [propget] HRESULT Format([out, retval] ParserFormat* retval);
    [propput] HRESULT Codepage([in] UINT newValue);
    [propget] HRESULT Codepage([out, retval] UINT* retval);
    [propget] HRESULT FTPItems([out, retval] IFTPItems** retval);
};
 
[
    object,
    uuid(3FCDE1F6-BB49-490C-B422-B3937D7B7F16),
    dual,
    nonextensible,
    helpstring("IUtils Interface"),
    pointer_default(unique)
]
interface IUtils : IDispatch
{
    [id(100), helpstring("method HashAlgoToString")] HRESULT HashAlgoToString([in] HashAlgo hashalgo, [out,retval] BSTR *retval);
    [id(101), helpstring("method KeyExchangeToString")] HRESULT KeyExchangeToString([in] KeyExchange keyexchange, [out,retval] BSTR *retval);
    [id(102), helpstring("method EncryptionToString")] HRESULT EncryptionToString([in] Encryption encryption, [out,retval] BSTR *retval);
    [id(103), helpstring("method HMACToString")] HRESULT HMACToString([in] HMAC mac, [out,retval] BSTR *retval);
    [id(104), helpstring("method SSHPublicKeyAlgoToString")] HRESULT SSHPublicKeyAlgoToString([in] SSHPublicKeyAlgo keyalgo, [out,retval] BSTR *retval);
    [id(105), helpstring("method SSHCompressionToString")] HRESULT SSHCompressionToString([in] SSHCompression compression, [out,retval] BSTR *retval);
    [id(106), helpstring("method ProxyTypeToString")] HRESULT ProxyTypeToString([in] ProxyType proxytype, [out,retval] BSTR *retval);
    [id(107), helpstring("method ServerSoftwareToString")] HRESULT ServerSoftwareToString([in] ServerSoftware software, [out,retval] BSTR *retval);
    [id(108), helpstring("method FileTimeToUnixTime")] HRESULT FileTimeToUnixTime([in] FILETIME filetime, [out, retval] ULONGLONG *retval);
    [id(109), helpstring("method UnixTimeToFileTime")] HRESULT UnixTimeToFileTime([in] ULONGLONG unixTime, [out, retval] FILETIME *retval);
    [id(110), helpstring("method FileTimeToVariantTime")] HRESULT FileTimeToVariantTime([in] FILETIME filetime, [out, retval] DATE *retval);
    [id(111), helpstring("method VariantTimeToFileTime")] HRESULT VariantTimeToFileTime([in] DATE date, [out, retval] FILETIME *retval);
    [id(112), helpstring("method MessageFromHRESULT")] HRESULT MessageFromHRESULT([in] HRESULT result, [out, retval] BSTR* retval);
};
 
[
    object,
    uuid(A53A8E57-41F6-49d5-9495-2FF849A06F03),
    pointer_default(unique)
]
interface ISSHChannelClient : IUnknown
{
    HRESULT OnDetach();
    HRESULT OnClose();
    HRESULT OnData();
    HRESULT OnSend();
    HRESULT OnEof();    
};

[
    object,
    uuid(49D66525-9192-43C3-A767-C047A8168DDB),
    pointer_default(unique)
]
interface ISSHKeyBlobHelper : IUnknown
{
    HRESULT GetPublicKeyBlob([in] IKey* key, [out, retval] VARIANT* retval);
};
 
[
    object,
    uuid(306E71BD-B532-4F21-9036-41FBBB0DE83B),
    pointer_default(unique)
]
interface IBCryptKey : IKey
{
    HRESULT Initialize([in] LPCWSTR algorithmName);
    HRESULT InitializeEx([in] LPCWSTR algorithmName, [in] LPCWSTR curveName);
    HRESULT Generate([in] long bits);
};
 
[
    object,
    uuid(4B53484C-3C6F-4430-BB2B-B16CC220489B),
    pointer_default(unique)
]
interface INCryptKey : IKey
{
    HRESULT Initialize([in] LPCWSTR provider);
    HRESULT CreatePersistedKey([in] LPCWSTR algorithmName);
    HRESULT Generate([in] long bits);
};
 
[
    object,
    uuid(EF6EF546-4063-443B-98D7-E360CB31F124),
    nonextensible,
    pointer_default(unique),
    local
]
interface INCryptKeyCustom : IUnknown
{
    HRESULT Initialize([in] /*PCCERT_CONTEXT*/void* certContext);
    HRESULT GetHandle([out,retval] /*NCRYPT_KEY_HANDLE*/ULONG_PTR *retval);
};
 
[
  uuid(7A3A786C-EB8C-43b3-BC10-8D09ACF5D195),
  version(4.0),
  helpstring("SmartFTP FTP Library 4.0 Type Library")
]
library sfFTPLib
{
    importlib(STDOLE_TLB);
 
    typedef [v1_enum] enum _HRESULT
    {
        [helpstring("Operation pending")]                   FTPLIB_E_BUSY = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3101),
        [helpstring("Not connected")]                       FTPLIB_E_NOTCONNECTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3102),
        [helpstring("Timeout")]                             FTPLIB_E_TIMEOUT = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3103),
        [helpstring("No operation to abort")]               FTPLIB_E_NOOPERATION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3104),
        [helpstring("Not initialized")]                     FTPLIB_E_NOTINIT = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3105),
        [helpstring("Wrong reply")]                         FTPLIB_E_WRONGREPLY = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3106),
        [helpstring("More data is required to continue")]   FTPLIB_E_MOREDATA = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3108),
        [helpstring("Paused")]                              FTPLIB_E_PAUSED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3109),
        [helpstring("Connection setting mismatch")]         FTPLIB_E_SETTINGMISMATCH = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x310a),
        [helpstring("Connection not disconnected")]         FTPLIB_E_NOTDISCONNECTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x310b),
        [helpstring("Connection is closed")]                FTPLIB_E_CONNECTIONCLOSED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x310c),
        [helpstring("Data connection failure")]             FTPLIB_E_DATACONNECTION_CONNECT = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x310d),
        [helpstring("Authentication failed")]               FTPLIB_E_AUTHENTICATION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x310e),
        [helpstring("PORT command failed")]                 FTPLIB_E_PORTCOMMANDFAILED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x310f),
        [helpstring("Restart not permitted")]               FTPLIB_E_RESTARTNOTPERMITTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3110),
        [helpstring("Server protocol violation")]           FTPLIB_E_SERVERPROTOCOLVIOLATION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3111),
        [helpstring("Command not implemented")]             FTPLIB_E_COMMANDNOTIMPLEMENTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3112),
        [helpstring("Not a regular file")]                  FTPLIB_E_NOTAREGULARFILE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3113),
        [helpstring("Too many connections")]                FTPLIB_E_TOOMANYCONNECTIONS = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3114),
        [helpstring("PASV command failed")]                 FTPLIB_E_PASVCOMMANDFAILED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3115),
        [helpstring("TLS not supported")]                   FTPLIB_E_TLSNOTSUPPORTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3116),
        [helpstring("Host name expected")]                  FTPLIB_E_HOSTNAMEEXPECTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3117),
        [helpstring("Server policy requires TLS")]          FTPLIB_E_SERVERPOLICYREQUIRESTLS = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3118),
        [helpstring("The IP is banned")]                    FTPLIB_E_IPBANNED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3119),
        [helpstring("Home directory")]                      FTPLIB_E_HOMEDIRECTORY = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x311a),
        [helpstring("Box: User needs to accept terms of service")] FTPLIB_E_BOX_ACCEPTTERMSOFSERVICE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x311b),
        [helpstring("Box: The application is blocked by your administrator")] FTPLIB_E_BOX_APPLICATIONBLOCKED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x311c),
        [helpstring("Box: Captcha is required")] FTPLIB_E_BOX_CAPTCHAREQUIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x311d),
        [helpstring("Local policy requires CCC")] FTPLIB_E_LOCALPOLICYREQUIRESCCC = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x311e),
        [helpstring("Not logged in")]                       FTPLIB_E_NOTLOGGEDIN = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x311f),
        [helpstring("The server's user limit has been reached")] FTPLIB_E_TOOMANYUSERS = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3129),
        [helpstring("TLS data session token error")] FTPLIB_E_TLSDATASESSIONTOKENERROR = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x312B),
        [helpstring("Could not create file")] FTPLIB_E_COULDNOTCREATEFILE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x312C),
 
        // SSH specific
        [helpstring("Unexpected remote id")]                FTPLIB_E_SSH_UNEXPECTEDREMOTEID = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3120),
        [helpstring("Host authentication failed")]          FTPLIB_E_SSH_HOSTAUTHENTICATION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3121),
        [helpstring("Algorithm negotiation failed")]        FTPLIB_E_SSH_NEGOTIATION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3122),
        [helpstring("Invalid host key")]                    FTPLIB_E_SSH_INVALIDHOSTKEY = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3123),
        [helpstring("Invalid message")]                     FTPLIB_E_SSH_INVALIDMESSAGE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3124),       
        [helpstring("Failed to request channel")]           FTPLIB_E_SSH_CHANNEL_REQUESTFAILURE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3125),
        [helpstring("Failed to open channel")]              FTPLIB_E_SSH_CHANNEL_OPENFAILURE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3126),
        [helpstring("Key exchange failed")]                 FTPLIB_E_SSH_KEYEXCHANGE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3127),
        [helpstring("Channel eof")]                         FTPLIB_E_SSH_CHANNEL_EOF = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3128),
        [helpstring("Invalid host signature")]              FTPLIB_E_SSH_INVALIDHOSTSIGNATURE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x312A),
        [helpstring("Host key rejected")]                   FTPLIB_E_SSH_HOSTKEYREJECTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x312D),
    
        [helpstring("Wrong password")]                      FTPLIB_E_KEYFILE_PASSWORD = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3130),
        [helpstring("Invalid format")]                      FTPLIB_E_KEYFILE_INVALIDFORMAT = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3131),
        [helpstring("Key is invalid")]                      FTPLIB_E_KEY_INVALID = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3132),
        [helpstring("Unsupported algorithm")]               FTPLIB_E_KEYFILE_UNSUPPORTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3133),
    
        // SFTP
        [helpstring("Unexpected SFTP packet type")]         FTPLIB_E_SFTP_UNEXPECTEDPACKETTYPE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3140),
        [helpstring("SFTP status error")]                   FTPLIB_E_SFTP_STATUSERROR = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3141),
        [helpstring("Invalid message")]                     FTPLIB_E_SFTP_INVALIDMESSAGE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3142),
 
        // FTP more
        [helpstring("Command not implemented for argument")] FTPLIB_E_COMMANDNOTIMPLEMENTEDFORARGUMENT = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3150),
        [helpstring("Character conversion failed")] FTPLIB_E_CHARACTERCONVERSION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3151),
        [helpstring("SSH server detected")] FTPLIB_E_SSHSERVERDETECTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3152),    
    
        // License
        [helpstring("License: Feature not licensed")]       FTPLIB_E_LICENSE_FEATURENOTLICENSED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3200),
        [helpstring("License: Product mismatch")]           FTPLIB_E_LICENSE_PRODUCTMISMATCH = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3201),
        [helpstring("License: Version mismatch")]           FTPLIB_E_LICENSE_VERSIONMISMATCH = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3202),
        [helpstring("License: MachineId mismatch")]         FTPLIB_E_LICENSE_MACHINEIDMISMATCH = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3203),
        [helpstring("License: License expired")]            FTPLIB_E_LICENSE_EXPIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3204),
        [helpstring("License: Maintenance expired")]        FTPLIB_E_LICENSE_MAINTENANCEEXPIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x3205),
 
        // License activation error codes
        [helpstring("Activation: Unsupported version")]     FTPLIB_E_ACTIVATION_UNSUPPORTEDVERSION = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5500),
        [helpstring("Activation: Invalid serial")]          FTPLIB_E_ACTIVATION_INVALIDSERIAL = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5501),
        [helpstring("Activation: Product mismatch")]        FTPLIB_E_ACTIVATION_PRODUCTMISMATCH = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5502),
        [helpstring("Activation: License inactive")]        FTPLIB_E_ACTIVATION_LICENSEINACTIVE = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5503),
        [helpstring("Activation: License expired")]         FTPLIB_E_ACTIVATION_LICENSEEXPIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5504),
        [helpstring("Activation: License exhausted")]       FTPLIB_E_ACTIVATION_LICENSEEXHAUSTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5505),
        [helpstring("Activation: Invalid request")]         FTPLIB_E_ACTIVATION_INVALIDREQUEST = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5506),
        [helpstring("Activation: SubLicense not found")]    FTPLIB_E_ACTIVATION_SUBLICENSENOTFOUND = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5507),
        [helpstring("Activation: Maintenance expired")]     FTPLIB_E_ACTIVATION_MAINTENANCEEXPIRED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5508),
        [helpstring("Activation: SubLicense disabled")]     FTPLIB_E_ACTIVATION_SUBLICENSEDISABLED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x5509),
        [helpstring("Activation: Product version not supported")]       FTPLIB_E_ACTIVATION_PRODUCTVERSIONNOTSUPPORTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x550A),
        [helpstring("Activation: Operating system not supported")]      FTPLIB_E_ACTIVATION_OPERATINGSYSTEMNOTSUPPORTED = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0x550B)
    } _HRESULT;

    typedef [v1_enum] enum UnixPermissions
    {
        // --- Public (World/Other) Permissions ---
        [helpstring("UnixPermission ftpUnixPermission PublicExecute")]
        ftpUnixPermissionPublicExecute = 0x0001,

        [helpstring("UnixPermission ftpUnixPermission PublicWrite")]
        ftpUnixPermissionPublicWrite = 0x0002,

        [helpstring("UnixPermission ftpUnixPermission PublicRead")]
        ftpUnixPermissionPublicRead = 0x0004,
 
 
        // --- Group Permissions ---
        [helpstring("UnixPermission ftpUnixPermission GroupExecute")]
        ftpUnixPermissionGroupExecute = 0x0008,

        [helpstring("UnixPermission ftpUnixPermission GroupWrite")]
        ftpUnixPermissionGroupWrite = 0x0010,

        [helpstring("UnixPermission ftpUnixPermission GroupRead")]
        ftpUnixPermissionGroupRead = 0x0020,
 
 
        // --- User (Owner) Permissions ---
        [helpstring("UnixPermission ftpUnixPermission UserExecute")]
        ftpUnixPermissionUserExecute = 0x0040,

        [helpstring("UnixPermission ftpUnixPermission UserWrite")]
        ftpUnixPermissionUserWrite = 0x0080,

        [helpstring("UnixPermission ftpUnixPermission UserRead")]
        ftpUnixPermissionUserRead = 0x0100,
 
 
        // --- Special Bits ---
        [helpstring("UnixPermission ftpUnixPermission SystemSticky")]
        ftpUnixPermissionSystemSticky = 0x0200,

        [helpstring("UnixPermission ftpUnixPermission SetGID")]
        ftpUnixPermissionSystemSetGID = 0x0400,

        [helpstring("UnixPermission ftpUnixPermission SetUID")]
        ftpUnixPermissionSystemSetUID = 0x0800
 
    } UnixPermissions;
 
    // mapped from SSH_FILEXFER_ATTR_FLAGS_
    typedef [v1_enum] enum SFTPItemAttributeBit
    {
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit ReadOnly")]           ftpSFTPItemAttributeBitReadOnly = 0x1,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit System")]         ftpSFTPItemAttributeBitSystem = 0x2,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Hidden")]         ftpSFTPItemAttributeBitHidden = 0x4,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit CaseInsensitive")]    ftpSFTPItemAttributeBitCaseInsensitive = 0x8,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Archive")]            ftpSFTPItemAttributeBitArchive = 0x10,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Encrypted")]      ftpSFTPItemAttributeBitEncrypted = 0x20,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Compressed")]     ftpSFTPItemAttributeBitCompressed = 0x40,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Sparse")]         ftpSFTPItemAttributeBitSparse = 0x80,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit AppendOnly")]     ftpSFTPItemAttributeBitAppendOnly = 0x100,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Immutable")]      ftpSFTPItemAttributeBitImmutable = 0x200,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit Sync")]               ftpSFTPItemAttributeBitSync = 0x400,
        [helpstring("SFTPItemAttributeBit ftpSFTPItemAttributeBit TranslationErr")] ftpSFTPItemAttributeBitTranslationErr = 0x800
    } SFTPItemAttributeBit;
 
    // mapped from SSH_FILEXFER_ATTR_
    typedef [v1_enum] enum SFTPItemAttribute
    {
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute Size")]             ftpSFTPItemAttributeSize = 0x1,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute UIDGID")]           ftpSFTPItemAttributeUIDGID = 0x2,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute Permissions")]      ftpSFTPItemAttributePermissions = 0x4,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute AccessTime")]       ftpSFTPItemAttributeAccessTime = 0x8,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute CreateTime")]       ftpSFTPItemAttributeCreateTime = 0x10,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute ModifyTime")]       ftpSFTPItemAttributeModifyTime = 0x20,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute ACL")]              ftpSFTPItemAttributeACL = 0x40,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute OwnerGroup")]       ftpSFTPItemAttributeOwnerGroup = 0x80,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute SubSecondTimes")]   ftpSFTPItemAttributeSubSecondTimes = 0x100,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute Bits")]             ftpSFTPItemAttributeBits = 0x200,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute AllocationSize")]   ftpSFTPItemAttributeAllocationSize = 0x400,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute TextHint")]         ftpSFTPItemAttributeTextHint = 0x800,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute MimeType")]         ftpSFTPItemAttributeMimeType = 0x1000,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute LinkCount")]        ftpSFTPItemAttributeLinkCount = 0x2000,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute UntranslatedName")] ftpSFTPItemAttributeUntranslatedName = 0x4000,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute CTime")]            ftpSFTPItemAttributeCTime = 0x8000,
        [helpstring("SFTPItemAttribute ftpSFTPItemAttribute Extended")]         ftpSFTPItemAttributeExtended = 0x80000000
    } SFTPItemAttribute;

    typedef [v1_enum] enum LISTOption
    {
        [helpstring("LISTOption ftpLISTOption Long")]
        ftpLISTOptionLong = 0x0001,

        [helpstring("LISTOption ftpLISTOption All")]
        ftpLISTOptionAll = 0x0002,

        [helpstring("LISTOption ftpLISTOption Links")]
        ftpLISTOptionLinks = 0x0004,

        [helpstring("LISTOption ftpLISTOption T")]
        ftpLISTOptionT = 0x0008,

        [helpstring("LISTOption ftpLISTOption Recursive")]
        ftpLISTOptionRecursive = 0x0010
    } LISTOption;

    typedef [v1_enum] enum DownloadFlags
    {
        [helpstring("DownloadFlags ftpDownloadFlag None")]      
        ftpDownloadFlagNone = 0x0,

        [helpstring("DownloadFlags ftpDownloadFlag ReadBeyondEnd")]     
        ftpDownloadFlagReadBeyondEnd = 0x1
 
    } DownloadFlags;

    typedef [v1_enum] enum SSHAuthentication
    {
        [helpstring("SSHAuthentication Unknown")]
        ftpSSHAuthenticationUnknown = 0,

        [helpstring("SSHAuthentication None")]
        ftpSSHAuthenticationNone = 1,

        [helpstring("SSHAuthentication Password")]
        ftpSSHAuthenticationPassword = 2,

        [helpstring("SSHAuthentication KeyboardInteractive")]
        ftpSSHAuthenticationKeyboardInteractive = 3,

        [helpstring("SSHAuthentication PublicKey")]
        ftpSSHAuthenticationPublicKey = 4,

        [helpstring("SSHAuthentication SecurID")]
        ftpSSHAuthenticationSecurID = 5,

        [helpstring("SSHAuthentication HostBased")]
        ftpSSHAuthenticationHostBased = 6,

        [helpstring("SSHAuthentication GSSAPI")]
        ftpSSHAuthenticationGSSAPI = 7
    } SSHAuthentication;

    [
        uuid(D216FD3A-DAC1-4692-AAE1-EB5551128990),
        nonextensible,
        helpstring("Event interface for FTPConnection")
    ]
    dispinterface _IFTPConnectionEvents
    {
        properties:
 
        methods:
            [id(1), helpstring("method OnDisconnect")] void OnDisconnect();
            [id(2), helpstring("method OnLogin")] void OnLogin();
            [id(3), helpstring("method OnVerifyCert")] void OnVerifyCert([in,out] VARIANT_BOOL* shouldContinue);
    };
 
    [ 
        object,
        uuid(0B79DE64-B5EB-430E-90F9-291F20ECDC3A),
        pointer_default(unique)
    ]
    interface IFTPConnectionEvents : IUnknown
    {
        HRESULT OnDisconnect();
        HRESULT OnLogin();
        HRESULT OnVerifyCert([in,out] VARIANT_BOOL* shouldContinue);
    };

    [
        uuid(50177264-39E2-43EC-8377-E1A97AB63ED2),
        helpstring("FTPConnectionSTA Class"),
    ]
    coclass FTPConnectionSTA
    {
        [default] interface IFTPConnection;
        [default, source] dispinterface _IFTPConnectionEvents;
    };

    [
        uuid(B32243B2-7D9E-464D-A2A4-4117540E0F70),
        helpstring("FTPConnectionMTA Class"),
    ]
    coclass FTPConnectionMTA
    {
        [default] interface IFTPConnection;
        [default, source] dispinterface _IFTPConnectionEvents;
        [source] interface IFTPConnectionEvents;
        interface IConnection;
        interface IConnectionWithLogger;
    };

    [
        uuid(614D8CE6-3583-49af-BACE-4B92EB4C4A73),
        helpstring("FTPParser Class"),
    ]
    coclass FTPParser
    {
        interface IFTPParser;
        [default] dispinterface IFTPParserD;
    };

    [
        uuid(D7A7E08A-31B5-4b7b-8908-2F4530349C50),
        helpstring("FTPPortPool Class"),
    ]
    coclass FTPPortPool
    {
        [default] interface IFTPPortPool;
    };

    [
        uuid(0BBB9B85-DE7A-4DE5-90C1-82ACF2AE6FA2),
        helpstring("FTPFXP Class"),
    ]
    coclass FTPFXP
    {
        [default] interface IFTPFXP;
    };

    [
        uuid(B46A15B8-9AA5-41A4-897D-B58A809B2D5B),
        helpstring("GlobalSpeedLimit Class"),
    ]
    coclass GlobalSpeedLimit
    {
        [default] interface IGlobalSpeedLimit;
    };

    [
        uuid(52D6E699-9256-414F-8FCD-F38FDF6AC8EE),
        helpstring("Global Class"),
    ]
    coclass Global
    {
        [default] interface IGlobal;
    };

    [
        uuid(2A49E162-7159-4F6F-BA7D-FC110DC0C603),
        nonextensible,
        helpstring("_ISFTPConnectionEvents Interface")
    ]
    dispinterface _ISFTPConnectionEvents
    {
        properties:
        methods:

        [id(3), helpstring("method OnClose")]
        void OnClose();
    };

    [
        object,
        uuid(1FFFC239-2D50-4049-BF97-F98671CB7EB7),
        pointer_default(unique)
    ]
    interface ISFTPConnectionEvents : IUnknown
    {
        HRESULT OnClose();
    };

    [
        uuid(066D6AC8-34D6-450b-B92F-17C8F6CC5E44),
        nonextensible,
        helpstring("_ISSHConnectionEvents Interface")
    ]
    dispinterface _ISSHConnectionEvents
    {
        properties:
        methods:
            [id(3), helpstring("method OnDisconnect")]
            void OnDisconnect();

            [id(11), helpstring("method OnLogin")]
            void OnLogin();

            [id(13), helpstring("method OnHostKey")]
            void OnHostKey([in] VARIANT varHostKey,[in, out] VARIANT_BOOL* accept);

            [id(14), helpstring("method OnLoginChallenge")]
            void OnLoginChallenge([in] BSTR challenge,[out] BSTR* response);

            [id(15), helpstring("method OnUserAuthBanner")]
            void OnUserAuthBanner([in] BSTR message);

            [id(16), helpstring("method OnPasswordChangeRequest")]
            void OnPasswordChangeRequest([in] BSTR prompt,[out] BSTR* newPassword,[in, out] VARIANT_BOOL* handled);

            [id(19), helpstring("method OnAuthentication")]
            void OnAuthentication([in] BSTR method);

            [id(20), helpstring("method OnHostKeys")]
            void OnHostKeys([in] VARIANT hostKeys);
    };
 
    [
        object,
        uuid(75B7A9CA-430E-49E7-A5D3-EA371143DA8C),
        pointer_default(unique)
    ]
    interface ISSHConnectionEvents : IUnknown
    {
        HRESULT OnDisconnect();
        HRESULT OnLogin();
        HRESULT OnHostKey([in] VARIANT varHostKey, [in, out] VARIANT_BOOL* accept);
        HRESULT OnLoginChallenge([in] LPCWSTR challenge, [out] BSTR *response);
        HRESULT OnUserAuthBanner([in] LPCWSTR message);
        HRESULT OnPasswordChangeRequest([in] LPCWSTR prompt, [out] BSTR *newPassword, [in, out] VARIANT_BOOL* handled);
        HRESULT OnAuthentication([in] LPCWSTR method);
        HRESULT OnHostKeys([in, size_is(numberOfKeys)] const PROPVARIANT hostKeys[*], [in] UINT numberOfKeys);
    };

    [
        uuid(08E560E0-86E2-4DDE-A397-E7C82DE9CD94),
        helpstring("SFTPConnection Class")
    ]
    coclass SFTPConnection
    {
        [default] interface ISFTPConnection;

        [default, source] dispinterface _ISFTPConnectionEvents;

        [source] interface ISFTPConnectionEvents;
    };

    [
        uuid(DCA42CB3-D61B-4B82-888D-E3D893E28EE8),
        helpstring("FTPItem Class")
    ]
    coclass FTPItem
    {
        [default] interface IFTPItem;
    };
 
    [
        uuid(F0B71643-5FE6-4FCA-89F5-525F06F580DD),
        helpstring("OpenSSLKey Class")
    ]
    coclass OpenSSLKey
    {
        [default] interface IOpenSSLKey;
    };

    [
        uuid(A9A48E15-6303-491D-9E6E-96F0E2418A1E),
        helpstring("KeyManager Class")
    ]
    coclass KeyManager
    {
        [default] interface IKeyManager;
    };
 
    [
        uuid(AAC5FE7F-3615-4D42-B913-C22EACEF1363),
        helpstring("AES128CTRWriteStream Class")
    ]
    coclass AES128CTRWriteStream
    {
        [default] interface IAES128CTRWriteStream;
        interface IStreamFilter;
        interface IStreamFilterInfo;
    };
 
    [
        uuid(026F6EBB-0A23-4585-B2E5-E167B0C34D17),
        helpstring("AES128CTRReadStream Class")
    ]
    coclass AES128CTRReadStream
    {
        [default] interface IAES128CTRReadStream;
        interface IStreamFilter;
        interface IStreamFilterInfo;
    };
 
    [
        uuid(2D7B4FA9-1507-4EE1-9CFD-12159C91EB9C),
        helpstring("CryptoHash Class")
    ]
    coclass CryptoHash
    {
        [default] interface ICryptoHash;
    };

    [
        uuid(1679D561-2D4C-453D-B11A-52BED2E29B12),
        helpstring("FTPClientId Class")
    ]
    coclass FTPClientId
    {
        [default] interface IFTPClientId;
    };
 
    [
        uuid(B6DFA153-8930-4FB4-8FE3-2D0D76422764),
        helpstring("ParserWriteStream Class")
    ]
    coclass ParserWriteStream
    {
        [default] interface IParserWriteStream;
    };
 
    [
        uuid(2AF42C62-29E4-4B68-8EB2-F63B6B5701F3),
        helpstring("SFTPVendorId Class")
    ]
    coclass SFTPVendorId
    {
        [default] interface ISFTPVendorId;
    };

    [
        uuid(A1B47E91-51FC-42AC-A661-31C78534DF7D),
        helpstring("SSHConnection Class")
    ]
    coclass SSHConnection
    {
        [default] interface ISSHConnection;

        [default, source] dispinterface _ISSHConnectionEvents;

        [source] interface ISSHConnectionEvents;
    };
 
    [
        uuid(2D9B03D3-392A-42DB-96F2-37F58A4E98D3),
        helpstring("Utils Class")
    ]
    coclass Utils
    {
        [default] interface IUtils;
    };
 
    [
        uuid(21BA1BBB-59C8-4D94-9C59-5F5A73115310),
        helpstring("SSHKeyBlobHelper Class")
    ]
    coclass SSHKeyBlobHelper
    {
        [default] interface ISSHKeyBlobHelper;
    };
 
    [
        uuid(8640D9C2-8B88-41D6-BA21-414A1561EA59),
        helpstring("BCryptKey Class")
    ]
    coclass BCryptKey
    {
        [default] interface IBCryptKey;
    };
 
    [
        uuid(06099E23-684A-4D60-8D2C-83D666C75123),
        helpstring("NCryptKey Class")
    ]
    coclass NCryptKey
    {
        [default] interface INCryptKey;
        interface INCryptKeyCustom;
    };
 
    [
        uuid(7AC02032-BBB0-4A4F-BB4F-E92C5A225A28),
        helpstring("FileLogger Class")
    ]
    coclass FileLogger
    {
        [default] interface IFileLogger;
    };
};